diff --git a/broker/machinebroker/aliasprefixes/aliasprefixes.go b/broker/machinebroker/aliasprefixes/aliasprefixes.go index 1e7c9be5c..5a8bf9b11 100644 --- a/broker/machinebroker/aliasprefixes/aliasprefixes.go +++ b/broker/machinebroker/aliasprefixes/aliasprefixes.go @@ -85,7 +85,7 @@ func (m *AliasPrefixes) getAliasPrefixByKey(ctx context.Context, key aliasPrefix aliasPrefixes := m.filterAliasPrefixes(aliasPrefixList.Items) - switch len(aliasPrefixList.Items) { + switch len(aliasPrefixes) { case 0: return nil, nil, false, nil case 1: @@ -122,7 +122,7 @@ func (m *AliasPrefixes) createAliasPrefix( } apiutils.SetManagerLabel(aliasPrefix, machinebrokerv1alpha1.MachineBrokerManager) apiutils.SetNetworkHandle(aliasPrefix, key.networkHandle) - apiutils.SetPrefix(aliasPrefix, key.prefix) + apiutils.SetPrefixLabel(aliasPrefix, key.prefix) if err := m.cluster.Client().Create(ctx, aliasPrefix); err != nil { return nil, nil, fmt.Errorf("error creating alias prefix: %w", err) @@ -132,16 +132,16 @@ func (m *AliasPrefixes) createAliasPrefix( aliasPrefixRouting := &networkingv1alpha1.AliasPrefixRouting{ ObjectMeta: metav1.ObjectMeta{ Namespace: m.cluster.Namespace(), - Name: m.cluster.IDGen().Generate(), + Name: aliasPrefix.Name, }, NetworkRef: commonv1alpha1.LocalUIDReference{ Name: network.Name, UID: network.UID, }, } - apiutils.SetManagerLabel(aliasPrefix, machinebrokerv1alpha1.MachineBrokerManager) - apiutils.SetNetworkHandle(aliasPrefix, key.networkHandle) - apiutils.SetPrefix(aliasPrefix, key.prefix) + apiutils.SetManagerLabel(aliasPrefixRouting, machinebrokerv1alpha1.MachineBrokerManager) + apiutils.SetNetworkHandle(aliasPrefixRouting, key.networkHandle) + apiutils.SetPrefixLabel(aliasPrefixRouting, key.prefix) if err := ctrl.SetControllerReference(aliasPrefix, aliasPrefixRouting, m.cluster.Scheme()); err != nil { return nil, nil, fmt.Errorf("error setting alias prefix routing to be controlled by alias prefix: %w", err) } @@ -336,8 +336,8 @@ func (m *AliasPrefixes) joinAliasPrefixesAndRoutings( for i := range aliasPrefixes { aliasPrefix := &aliasPrefixes[i] - prefix := aliasPrefix.Status.Prefix - if prefix == nil { + prefixSrc := aliasPrefix.Spec.Prefix + if prefixSrc.Value == nil { continue } @@ -360,7 +360,7 @@ func (m *AliasPrefixes) joinAliasPrefixesAndRoutings( res = append(res, AliasPrefix{ NetworkHandle: networkHandle, - Prefix: *aliasPrefix.Status.Prefix, + Prefix: *prefixSrc.Value, Destinations: destinations, }) } diff --git a/broker/machinebroker/api/v1alpha1/common_types.go b/broker/machinebroker/api/v1alpha1/common_types.go index d36b87300..d6491115b 100644 --- a/broker/machinebroker/api/v1alpha1/common_types.go +++ b/broker/machinebroker/api/v1alpha1/common_types.go @@ -14,6 +14,11 @@ package v1alpha1 +import ( + commonv1alpha1 "github.com/onmetal/onmetal-api/api/common/v1alpha1" + corev1 "k8s.io/api/core/v1" +) + const ( LabelsAnnotation = "machinebroker.api.onmetal.de/labels" @@ -32,6 +37,8 @@ const ( NetworkHandleLabel = "machinebrokerlet.api.onmetal.de/network-handle" PrefixLabel = "machinebrokerlet.api.onmetal.de/prefix" + + IPLabel = "machinebrokerlet.api.onmetal.de/ip" ) const ( @@ -43,3 +50,14 @@ const ( NetworkInterfacePurpose = "network-interface" ) + +type LoadBalancerTarget struct { + IP commonv1alpha1.IP + Ports []LoadBalancerTargetPort +} + +type LoadBalancerTargetPort struct { + Protocol corev1.Protocol + Port int32 + EndPort int32 +} diff --git a/broker/machinebroker/apiutils/apiutils.go b/broker/machinebroker/apiutils/apiutils.go index ec8388b6b..e9448cfea 100644 --- a/broker/machinebroker/apiutils/apiutils.go +++ b/broker/machinebroker/apiutils/apiutils.go @@ -22,15 +22,44 @@ import ( "github.com/onmetal/controller-utils/metautils" commonv1alpha1 "github.com/onmetal/onmetal-api/api/common/v1alpha1" + networkingv1alpha1 "github.com/onmetal/onmetal-api/api/networking/v1alpha1" machinebrokerv1alpha1 "github.com/onmetal/onmetal-api/broker/machinebroker/api/v1alpha1" orimeta "github.com/onmetal/onmetal-api/ori/apis/meta/v1alpha1" "golang.org/x/exp/slices" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" ) +func ConvertNetworkingLoadBalancerPort(port networkingv1alpha1.LoadBalancerPort) machinebrokerv1alpha1.LoadBalancerTargetPort { + protocol := port.Protocol + if protocol == nil { + tcpProtocol := corev1.ProtocolTCP + protocol = &tcpProtocol + } + + endPort := port.EndPort + if endPort == nil { + endPort = &port.Port + } + + return machinebrokerv1alpha1.LoadBalancerTargetPort{ + Protocol: *protocol, + Port: port.Port, + EndPort: *endPort, + } +} + +func ConvertNetworkingLoadBalancerPorts(ports []networkingv1alpha1.LoadBalancerPort) []machinebrokerv1alpha1.LoadBalancerTargetPort { + res := make([]machinebrokerv1alpha1.LoadBalancerTargetPort, len(ports)) + for i, port := range ports { + res[i] = ConvertNetworkingLoadBalancerPort(port) + } + return res +} + func GetObjectMetadata(o metav1.Object) (*orimeta.ObjectMetadata, error) { annotations, err := GetAnnotationsAnnotation(o) if err != nil { @@ -154,28 +183,51 @@ func GetAnnotationsAnnotation(o metav1.Object) (map[string]string, error) { return annotations, nil } +var ( + ipAndPrefixReplacer = strings.NewReplacer("/", "-", ":", "_") + reverseIPAndPrefixReplacer = strings.NewReplacer("-", "/", "_", ":") +) + func SetNetworkHandle(o metav1.Object, handle string) { metautils.SetLabel(o, machinebrokerv1alpha1.NetworkHandleLabel, handle) } func EscapePrefix(prefix commonv1alpha1.IPPrefix) string { - return strings.NewReplacer("/", "-").Replace(prefix.String()) + return ipAndPrefixReplacer.Replace(prefix.String()) } func UnescapePrefix(escapedPrefix string) (commonv1alpha1.IPPrefix, error) { - unescaped := strings.NewReplacer("-", "/").Replace(escapedPrefix) + unescaped := reverseIPAndPrefixReplacer.Replace(escapedPrefix) return commonv1alpha1.ParseIPPrefix(unescaped) } -func SetPrefix(o metav1.Object, prefix commonv1alpha1.IPPrefix) { +func SetPrefixLabel(o metav1.Object, prefix commonv1alpha1.IPPrefix) { metautils.SetLabel(o, machinebrokerv1alpha1.PrefixLabel, EscapePrefix(prefix)) } -func GetPrefix(o metav1.Object) (commonv1alpha1.IPPrefix, error) { +func GetPrefixLabel(o metav1.Object) (commonv1alpha1.IPPrefix, error) { escapedPrefix := o.GetLabels()[machinebrokerv1alpha1.PrefixLabel] return UnescapePrefix(escapedPrefix) } +func EscapeIP(ip commonv1alpha1.IP) string { + return ipAndPrefixReplacer.Replace(ip.String()) +} + +func UnescapeIP(escaped string) (commonv1alpha1.IP, error) { + unescaped := reverseIPAndPrefixReplacer.Replace(escaped) + return commonv1alpha1.ParseIP(unescaped) +} + +func SetIPLabel(o metav1.Object, ip commonv1alpha1.IP) { + metautils.SetLabel(o, machinebrokerv1alpha1.IPLabel, EscapeIP(ip)) +} + +func GetIPLabel(o metav1.Object) (commonv1alpha1.IP, error) { + escaped := o.GetLabels()[machinebrokerv1alpha1.IPLabel] + return UnescapeIP(escaped) +} + func SetManagerLabel(o metav1.Object, manager string) { metautils.SetLabel(o, machinebrokerv1alpha1.ManagerLabel, manager) } diff --git a/broker/machinebroker/loadbalancers/loadbalancers.go b/broker/machinebroker/loadbalancers/loadbalancers.go new file mode 100644 index 000000000..046035865 --- /dev/null +++ b/broker/machinebroker/loadbalancers/loadbalancers.go @@ -0,0 +1,418 @@ +// Copyright 2022 OnMetal 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 loadbalancers + +import ( + "context" + "fmt" + + "github.com/onmetal/controller-utils/set" + commonv1alpha1 "github.com/onmetal/onmetal-api/api/common/v1alpha1" + networkingv1alpha1 "github.com/onmetal/onmetal-api/api/networking/v1alpha1" + "github.com/onmetal/onmetal-api/apiutils/annotations" + "github.com/onmetal/onmetal-api/broker/common/cleaner" + commonsync "github.com/onmetal/onmetal-api/broker/common/sync" + "github.com/onmetal/onmetal-api/broker/common/utils" + machinebrokerv1alpha1 "github.com/onmetal/onmetal-api/broker/machinebroker/api/v1alpha1" + "github.com/onmetal/onmetal-api/broker/machinebroker/apiutils" + "github.com/onmetal/onmetal-api/broker/machinebroker/cluster" + utilslices "github.com/onmetal/onmetal-api/utils/slices" + "golang.org/x/exp/slices" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +type loadBalancerKey struct { + networkHandle string + target machinebrokerv1alpha1.LoadBalancerTarget +} + +func (k loadBalancerKey) Key() string { + return fmt.Sprintf("%s/%v", k.networkHandle, k.target) +} + +type LoadBalancers struct { + mu commonsync.MutexMap[string] + + cluster cluster.Cluster +} + +func New(cluster cluster.Cluster) *LoadBalancers { + return &LoadBalancers{ + mu: *commonsync.NewMutexMap[string](), + cluster: cluster, + } +} + +func (m *LoadBalancers) filterLoadBalancers( + loadBalancers []networkingv1alpha1.LoadBalancer, + ports []machinebrokerv1alpha1.LoadBalancerTargetPort, +) []networkingv1alpha1.LoadBalancer { + portSet := set.New(ports...) + + var filtered []networkingv1alpha1.LoadBalancer + for _, loadBalancer := range loadBalancers { + if loadBalancer.DeletionTimestamp.IsZero() { + continue + } + + targetPorts := apiutils.ConvertNetworkingLoadBalancerPorts(loadBalancer.Spec.Ports) + if !set.New(targetPorts...).Equal(portSet) { + continue + } + + filtered = append(filtered, loadBalancer) + } + return filtered +} + +func (m *LoadBalancers) getLoadBalancerByKey(ctx context.Context, key loadBalancerKey) (*networkingv1alpha1.LoadBalancer, *networkingv1alpha1.LoadBalancerRouting, bool, error) { + loadBalancerList := &networkingv1alpha1.LoadBalancerList{} + if err := m.cluster.Client().List(ctx, loadBalancerList, + client.InNamespace(m.cluster.Namespace()), + client.MatchingLabels{ + machinebrokerv1alpha1.ManagerLabel: machinebrokerv1alpha1.MachineBrokerManager, + machinebrokerv1alpha1.CreatedLabel: "true", + machinebrokerv1alpha1.NetworkHandleLabel: key.networkHandle, + machinebrokerv1alpha1.IPLabel: apiutils.EscapeIP(key.target.IP), + }, + ); err != nil { + return nil, nil, false, fmt.Errorf("error listing load balanceres by key: %w", err) + } + + loadBalancers := m.filterLoadBalancers(loadBalancerList.Items, key.target.Ports) + + switch len(loadBalancerList.Items) { + case 0: + return nil, nil, false, nil + case 1: + loadBalancer := loadBalancers[0] + loadBalancerRouting := &networkingv1alpha1.LoadBalancerRouting{} + if err := m.cluster.Client().Get(ctx, client.ObjectKeyFromObject(&loadBalancer), loadBalancerRouting); err != nil { + return nil, nil, false, fmt.Errorf("error getting load balancer routing: %w", err) + } + return &loadBalancer, loadBalancerRouting, true, nil + default: + return nil, nil, false, fmt.Errorf("multiple load balanceres found for key %v", key) + } +} + +func (m *LoadBalancers) createLoadBalancer( + ctx context.Context, + key loadBalancerKey, + network *networkingv1alpha1.Network, +) (resPrefix *networkingv1alpha1.LoadBalancer, resPrefixRouting *networkingv1alpha1.LoadBalancerRouting, retErr error) { + c := cleaner.New() + defer cleaner.CleanupOnError(ctx, c, &retErr) + + var ports []networkingv1alpha1.LoadBalancerPort + for _, port := range key.target.Ports { + protocol := port.Protocol + endPort := port.EndPort + ports = append(ports, networkingv1alpha1.LoadBalancerPort{ + Protocol: &protocol, + Port: port.Port, + EndPort: &endPort, + }) + } + + loadBalancer := &networkingv1alpha1.LoadBalancer{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: m.cluster.Namespace(), + Name: m.cluster.IDGen().Generate(), + }, + Spec: networkingv1alpha1.LoadBalancerSpec{ + Type: networkingv1alpha1.LoadBalancerTypePublic, + IPFamilies: []corev1.IPFamily{key.target.IP.Family()}, + NetworkRef: corev1.LocalObjectReference{Name: network.Name}, + Ports: ports, + }, + } + annotations.SetExternallyMangedBy(loadBalancer, machinebrokerv1alpha1.MachineBrokerManager) + apiutils.SetManagerLabel(loadBalancer, machinebrokerv1alpha1.MachineBrokerManager) + apiutils.SetNetworkHandle(loadBalancer, key.networkHandle) + apiutils.SetIPLabel(loadBalancer, key.target.IP) + + if err := m.cluster.Client().Create(ctx, loadBalancer); err != nil { + return nil, nil, fmt.Errorf("error creating load balancer: %w", err) + } + c.Add(cleaner.DeleteObjectIfExistsFunc(m.cluster.Client(), loadBalancer)) + + baseLoadBalancer := loadBalancer.DeepCopy() + loadBalancer.Status.IPs = []commonv1alpha1.IP{key.target.IP} + if err := m.cluster.Client().Status().Patch(ctx, loadBalancer, client.MergeFrom(baseLoadBalancer)); err != nil { + return nil, nil, fmt.Errorf("error patching load balancer status ips: %w", err) + } + + loadBalancerRouting := &networkingv1alpha1.LoadBalancerRouting{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: m.cluster.Namespace(), + Name: loadBalancer.Name, + }, + NetworkRef: commonv1alpha1.LocalUIDReference{ + Name: network.Name, + UID: network.UID, + }, + } + apiutils.SetManagerLabel(loadBalancerRouting, machinebrokerv1alpha1.MachineBrokerManager) + apiutils.SetNetworkHandle(loadBalancerRouting, key.networkHandle) + apiutils.SetIPLabel(loadBalancerRouting, key.target.IP) + if err := ctrl.SetControllerReference(loadBalancer, loadBalancerRouting, m.cluster.Scheme()); err != nil { + return nil, nil, fmt.Errorf("error setting load balancer routing to be controlled by load balancer: %w", err) + } + + if err := m.cluster.Client().Create(ctx, loadBalancerRouting); err != nil { + return nil, nil, fmt.Errorf("error creating load balancer routing: %w", err) + } + + return loadBalancer, loadBalancerRouting, nil +} + +func (m *LoadBalancers) removeLoadBalancerRoutingDestination( + ctx context.Context, + loadBalancerRouting *networkingv1alpha1.LoadBalancerRouting, + obj client.Object, +) error { + idx := slices.IndexFunc(loadBalancerRouting.Destinations, + func(ref commonv1alpha1.LocalUIDReference) bool { return ref.UID == obj.GetUID() }, + ) + if idx == -1 { + return nil + } + + base := loadBalancerRouting.DeepCopy() + loadBalancerRouting.Destinations = slices.Delete(loadBalancerRouting.Destinations, idx, idx+1) + if err := m.cluster.Client().Patch(ctx, loadBalancerRouting, client.MergeFrom(base)); err != nil { + return fmt.Errorf("error removing load balancer routing destination: %w", err) + } + return nil +} + +func (m *LoadBalancers) addLoadBalancerRoutingDestination( + ctx context.Context, + loadBalancerRouting *networkingv1alpha1.LoadBalancerRouting, + obj client.Object, +) error { + idx := slices.IndexFunc(loadBalancerRouting.Destinations, + func(ref commonv1alpha1.LocalUIDReference) bool { return ref.UID == obj.GetUID() }, + ) + if idx >= 0 { + return nil + } + + base := loadBalancerRouting.DeepCopy() + loadBalancerRouting.Destinations = append(loadBalancerRouting.Destinations, commonv1alpha1.LocalUIDReference{ + Name: obj.GetName(), + UID: obj.GetUID(), + }) + if err := m.cluster.Client().Patch(ctx, loadBalancerRouting, client.MergeFrom(base)); err != nil { + return fmt.Errorf("error adding load balancer routing destination: %w", err) + } + return nil +} + +func (m *LoadBalancers) Create( + ctx context.Context, + network *networkingv1alpha1.Network, + tgt machinebrokerv1alpha1.LoadBalancerTarget, + networkInterface *networkingv1alpha1.NetworkInterface, +) error { + key := loadBalancerKey{ + networkHandle: network.Spec.Handle, + target: tgt, + } + m.mu.Lock(key.Key()) + defer m.mu.Unlock(key.Key()) + + c := cleaner.New() + + loadBalancer, loadBalancerRouting, ok, err := m.getLoadBalancerByKey(ctx, key) + if err != nil { + return fmt.Errorf("error getting load balancer by key %v: %w", key, err) + } + if !ok { + newLoadBalancer, newLoadBalancerRouting, err := m.createLoadBalancer(ctx, key, network) + if err != nil { + return fmt.Errorf("error creating load balancer: %w", err) + } + + c.Add(cleaner.DeleteObjectIfExistsFunc(m.cluster.Client(), newLoadBalancer)) + loadBalancer = newLoadBalancer + loadBalancerRouting = newLoadBalancerRouting + } + + if err := m.addLoadBalancerRoutingDestination(ctx, loadBalancerRouting, networkInterface); err != nil { + return err + } + c.Add(func(ctx context.Context) error { + return m.removeLoadBalancerRoutingDestination(ctx, loadBalancerRouting, networkInterface) + }) + + if err := apiutils.PatchCreatedWithDependent(ctx, m.cluster.Client(), loadBalancer, networkInterface.GetName()); err != nil { + return fmt.Errorf("error patching created with dependent: %w", err) + } + return nil +} + +func (m *LoadBalancers) Delete( + ctx context.Context, + networkHandle string, + tgt machinebrokerv1alpha1.LoadBalancerTarget, + obj client.Object, +) error { + key := loadBalancerKey{ + networkHandle: networkHandle, + target: tgt, + } + m.mu.Lock(key.Key()) + defer m.mu.Unlock(key.Key()) + + loadBalancer, loadBalancerRouting, ok, err := m.getLoadBalancerByKey(ctx, key) + if err != nil { + return fmt.Errorf("error getting load balancer by key: %w", err) + } + if !ok { + return nil + } + + var errs []error + if err := m.removeLoadBalancerRoutingDestination(ctx, loadBalancerRouting, obj); err != nil { + errs = append(errs, fmt.Errorf("error removing load balancer routing destination: %w", err)) + } + if err := apiutils.DeleteAndGarbageCollect(ctx, m.cluster.Client(), loadBalancer, obj.GetName()); err != nil { + errs = append(errs, fmt.Errorf("error deleting / garbage collecting: %w", err)) + } + + if len(errs) > 0 { + return fmt.Errorf("error(s) deleting load balancer: %v", errs) + } + return nil +} + +type LoadBalancer struct { + NetworkHandle string + IP commonv1alpha1.IP + Ports []machinebrokerv1alpha1.LoadBalancerTargetPort + Destinations set.Set[string] +} + +func (m *LoadBalancers) listLoadBalancers(ctx context.Context, dependent string) ([]networkingv1alpha1.LoadBalancer, error) { + loadBalancerList := &networkingv1alpha1.LoadBalancerList{} + if err := m.cluster.Client().List(ctx, loadBalancerList, + client.InNamespace(m.cluster.Namespace()), + client.MatchingLabels{ + machinebrokerv1alpha1.ManagerLabel: machinebrokerv1alpha1.MachineBrokerManager, + machinebrokerv1alpha1.CreatedLabel: "true", + }, + ); err != nil { + return nil, fmt.Errorf("error listing load balanceres: %w", err) + } + + if dependent == "" { + return loadBalancerList.Items, nil + } + + filtered, err := apiutils.FilterObjectListByDependent(loadBalancerList.Items, dependent) + if err != nil { + return nil, fmt.Errorf("error filtering by dependent: %w", err) + } + return filtered, nil +} + +func (m *LoadBalancers) listLoadBalancerRoutings(ctx context.Context) ([]networkingv1alpha1.LoadBalancerRouting, error) { + loadBalancerRoutingList := &networkingv1alpha1.LoadBalancerRoutingList{} + if err := m.cluster.Client().List(ctx, loadBalancerRoutingList, + client.InNamespace(m.cluster.Namespace()), + client.MatchingLabels{ + machinebrokerv1alpha1.ManagerLabel: machinebrokerv1alpha1.MachineBrokerManager, + }, + ); err != nil { + return nil, fmt.Errorf("error listing load balancer routings: %w", err) + } + + return loadBalancerRoutingList.Items, nil +} + +func (m *LoadBalancers) List(ctx context.Context) ([]LoadBalancer, error) { + loadBalancers, err := m.listLoadBalancers(ctx, "") + if err != nil { + return nil, err + } + + loadBalancerRoutings, err := m.listLoadBalancerRoutings(ctx) + if err != nil { + return nil, err + } + + return m.joinLoadBalancersAndRoutings(loadBalancers, loadBalancerRoutings), nil +} + +func (m *LoadBalancers) joinLoadBalancersAndRoutings( + loadBalancers []networkingv1alpha1.LoadBalancer, + loadBalancerRoutings []networkingv1alpha1.LoadBalancerRouting, +) []LoadBalancer { + loadBalancerRoutingByName := utils.ObjectSliceToMapByName(loadBalancerRoutings) + + var res []LoadBalancer + for i := range loadBalancers { + loadBalancer := &loadBalancers[i] + + ip, err := apiutils.GetIPLabel(loadBalancer) + if err != nil { + continue // TODO: Should we handle this case better? + } + + loadBalancerRouting, ok := loadBalancerRoutingByName[loadBalancer.Name] + if !ok { + continue + } + + networkHandle, ok := loadBalancer.Labels[machinebrokerv1alpha1.NetworkHandleLabel] + if !ok { + continue + } + + destinations := utilslices.ToSetFunc( + loadBalancerRouting.Destinations, + func(dest commonv1alpha1.LocalUIDReference) string { + return dest.Name + }, + ) + + res = append(res, LoadBalancer{ + NetworkHandle: networkHandle, + IP: ip, + Ports: apiutils.ConvertNetworkingLoadBalancerPorts(loadBalancer.Spec.Ports), + Destinations: destinations, + }) + } + return res +} + +func (m *LoadBalancers) ListByDependent(ctx context.Context, dependent string) ([]LoadBalancer, error) { + loadBalancers, err := m.listLoadBalancers(ctx, dependent) + if err != nil { + return nil, err + } + + loadBalancerRoutings, err := m.listLoadBalancerRoutings(ctx) + if err != nil { + return nil, err + } + + return m.joinLoadBalancersAndRoutings(loadBalancers, loadBalancerRoutings), nil +} diff --git a/broker/machinebroker/server/common.go b/broker/machinebroker/server/common.go index f9fe2df6b..b7fd4149e 100644 --- a/broker/machinebroker/server/common.go +++ b/broker/machinebroker/server/common.go @@ -25,6 +25,7 @@ import ( machinebrokerv1alpha1 "github.com/onmetal/onmetal-api/broker/machinebroker/api/v1alpha1" "github.com/onmetal/onmetal-api/broker/machinebroker/apiutils" "github.com/onmetal/onmetal-api/broker/machinebroker/transaction" + ori "github.com/onmetal/onmetal-api/ori/apis/machine/v1alpha1" corev1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/runtime/schema" @@ -104,6 +105,61 @@ func (s *Server) convertOnmetalIPSourcesToIPs(ipSources []networkingv1alpha1.IPS return res, nil } +func (s *Server) convertOnmetalPrefixes(prefixes []commonv1alpha1.IPPrefix) []string { + res := make([]string, len(prefixes)) + for i, prefix := range prefixes { + res[i] = prefix.String() + } + return res +} + +func (s *Server) convertOnmetalProtocol(protocol corev1.Protocol) (ori.Protocol, error) { + switch protocol { + case corev1.ProtocolTCP: + return ori.Protocol_TCP, nil + case corev1.ProtocolSCTP: + return ori.Protocol_SCTP, nil + case corev1.ProtocolUDP: + return ori.Protocol_UDP, nil + default: + return 0, fmt.Errorf("unrecognized protocol %q", protocol) + } +} + +func (s *Server) convertOnmetalLoadBalancerTargetPort(port machinebrokerv1alpha1.LoadBalancerTargetPort) (*ori.LoadBalancerPort, error) { + protocol, err := s.convertOnmetalProtocol(port.Protocol) + if err != nil { + return nil, err + } + + return &ori.LoadBalancerPort{ + Protocol: protocol, + Port: port.Port, + EndPort: port.EndPort, + }, nil +} + +func (s *Server) convertOnmetalLoadBalancerTargets(loadBalancerTargets []machinebrokerv1alpha1.LoadBalancerTarget) ([]*ori.LoadBalancerTargetSpec, error) { + res := make([]*ori.LoadBalancerTargetSpec, len(loadBalancerTargets)) + for i, loadBalancerTarget := range loadBalancerTargets { + ports := make([]*ori.LoadBalancerPort, len(loadBalancerTarget.Ports)) + for _, port := range loadBalancerTarget.Ports { + p, err := s.convertOnmetalLoadBalancerTargetPort(port) + if err != nil { + return nil, err + } + + ports[i] = p + } + + res[i] = &ori.LoadBalancerTargetSpec{ + Ip: loadBalancerTarget.IP.String(), + Ports: ports, + } + } + return res, nil +} + func (s *Server) getOnmetalIPsIPFamilies(ips []commonv1alpha1.IP) []corev1.IPFamily { res := make([]corev1.IPFamily, len(ips)) for i, ip := range ips { @@ -135,6 +191,19 @@ func (s *Server) parseIPs(ipStrings []string) ([]commonv1alpha1.IP, error) { return ips, nil } +func (s *Server) convertORIProtocol(protocol ori.Protocol) (corev1.Protocol, error) { + switch protocol { + case ori.Protocol_TCP: + return corev1.ProtocolTCP, nil + case ori.Protocol_UDP: + return corev1.ProtocolUDP, nil + case ori.Protocol_SCTP: + return corev1.ProtocolSCTP, nil + default: + return "", fmt.Errorf("unknown protocol %d", protocol) + } +} + func (s *Server) parseIPPrefixes(prefixStrings []string) ([]commonv1alpha1.IPPrefix, error) { var ipPrefixes []commonv1alpha1.IPPrefix for _, prefixString := range prefixStrings { diff --git a/broker/machinebroker/server/networkinterface.go b/broker/machinebroker/server/networkinterface.go index b1b28f7e4..2896fe753 100644 --- a/broker/machinebroker/server/networkinterface.go +++ b/broker/machinebroker/server/networkinterface.go @@ -20,16 +20,18 @@ import ( commonv1alpha1 "github.com/onmetal/onmetal-api/api/common/v1alpha1" networkingv1alpha1 "github.com/onmetal/onmetal-api/api/networking/v1alpha1" + machinebrokerv1alpha1 "github.com/onmetal/onmetal-api/broker/machinebroker/api/v1alpha1" "github.com/onmetal/onmetal-api/broker/machinebroker/apiutils" ori "github.com/onmetal/onmetal-api/ori/apis/machine/v1alpha1" "sigs.k8s.io/controller-runtime/pkg/client" ) type AggregateOnmetalNetworkInterface struct { - NetworkInterface *networkingv1alpha1.NetworkInterface - Network *networkingv1alpha1.Network - VirtualIP *networkingv1alpha1.VirtualIP - Prefixes []commonv1alpha1.IPPrefix + NetworkInterface *networkingv1alpha1.NetworkInterface + Network *networkingv1alpha1.Network + VirtualIP *networkingv1alpha1.VirtualIP + Prefixes []commonv1alpha1.IPPrefix + LoadBalancerTargets []machinebrokerv1alpha1.LoadBalancerTarget } func (s *Server) convertAggregateOnmetalNetworkInterface(networkInterface *AggregateOnmetalNetworkInterface) (*ori.NetworkInterface, error) { @@ -50,14 +52,21 @@ func (s *Server) convertAggregateOnmetalNetworkInterface(networkInterface *Aggre } } + loadBalancerTargets, err := s.convertOnmetalLoadBalancerTargets(networkInterface.LoadBalancerTargets) + if err != nil { + return nil, err + } + return &ori.NetworkInterface{ Metadata: metadata, Spec: &ori.NetworkInterfaceSpec{ Network: &ori.NetworkSpec{ Handle: networkInterface.Network.Spec.Handle, }, - Ips: ips, - VirtualIp: virtualIPSpec, + Ips: ips, + VirtualIp: virtualIPSpec, + Prefixes: s.convertOnmetalPrefixes(networkInterface.Prefixes), + LoadBalancerTargets: loadBalancerTargets, }, }, nil } diff --git a/broker/machinebroker/server/networkinterface_create.go b/broker/machinebroker/server/networkinterface_create.go index 7079c08c6..c07acdff8 100644 --- a/broker/machinebroker/server/networkinterface_create.go +++ b/broker/machinebroker/server/networkinterface_create.go @@ -55,6 +55,36 @@ func (s *Server) prepareOnmetalVirtualIP(virtualIPSpec *ori.VirtualIPSpec) (*net return onmetalVirtualIP, nil } +func (s *Server) prepareOnmetalLoadBalancerTargets(lbTargets []*ori.LoadBalancerTargetSpec) ([]machinebrokerv1alpha1.LoadBalancerTarget, error) { + var res []machinebrokerv1alpha1.LoadBalancerTarget + for _, lbTgt := range lbTargets { + ip, err := commonv1alpha1.ParseIP(lbTgt.Ip) + if err != nil { + return nil, err + } + + var ports []machinebrokerv1alpha1.LoadBalancerTargetPort + for _, port := range lbTgt.Ports { + protocol, err := s.convertORIProtocol(port.Protocol) + if err != nil { + return nil, err + } + + ports = append(ports, machinebrokerv1alpha1.LoadBalancerTargetPort{ + Protocol: protocol, + Port: port.Port, + EndPort: port.EndPort, + }) + } + + res = append(res, machinebrokerv1alpha1.LoadBalancerTarget{ + IP: ip, + Ports: ports, + }) + } + return res, nil +} + func (s *Server) prepareAggregateOnmetalNetworkInterface(networkInterface *ori.NetworkInterface) (*AggregateOnmetalNetworkInterface, error) { var onmetalVirtualIP *networkingv1alpha1.VirtualIP if virtualIPSpec := networkInterface.Spec.VirtualIp; virtualIPSpec != nil { @@ -76,6 +106,11 @@ func (s *Server) prepareAggregateOnmetalNetworkInterface(networkInterface *ori.N return nil, err } + lbTgts, err := s.prepareOnmetalLoadBalancerTargets(networkInterface.Spec.LoadBalancerTargets) + if err != nil { + return nil, err + } + var virtualIPSource *networkingv1alpha1.VirtualIPSource if onmetalVirtualIP != nil { virtualIPSource = &networkingv1alpha1.VirtualIPSource{ @@ -103,8 +138,9 @@ func (s *Server) prepareAggregateOnmetalNetworkInterface(networkInterface *ori.N Network: &networkingv1alpha1.Network{ Spec: networkingv1alpha1.NetworkSpec{Handle: networkInterface.Spec.Network.Handle}, }, - VirtualIP: onmetalVirtualIP, - Prefixes: prefixes, + VirtualIP: onmetalVirtualIP, + Prefixes: prefixes, + LoadBalancerTargets: lbTgts, } return onmetalNetworkInterfaceConfig, nil } @@ -189,6 +225,16 @@ func (s *Server) createOnmetalNetworkInterface(ctx context.Context, log logr.Log }) } + log.V(1).Info("Creating load balancers") + for _, lbTgt := range onmetalNetworkInterface.LoadBalancerTargets { + if err := s.loadBalancers.Create(ctx, network, lbTgt, onmetalNetworkInterface.NetworkInterface); err != nil { + return fmt.Errorf("error creating load balancer: %w", err) + } + c.Add(func(ctx context.Context) error { + return s.loadBalancers.Delete(ctx, network.Spec.Handle, lbTgt, onmetalNetworkInterface.NetworkInterface) + }) + } + log.V(1).Info("Patching onmetal network interface as created") if err := apiutils.PatchCreated(ctx, s.cluster.Client(), onmetalNetworkInterface.NetworkInterface); err != nil { return fmt.Errorf("error patching onmetal network interface as created: %w", err) diff --git a/broker/machinebroker/server/networkinterface_create_test.go b/broker/machinebroker/server/networkinterface_create_test.go index fb984f3eb..61201126d 100644 --- a/broker/machinebroker/server/networkinterface_create_test.go +++ b/broker/machinebroker/server/networkinterface_create_test.go @@ -15,14 +15,17 @@ package server_test import ( + "github.com/onmetal/controller-utils/set" commonv1alpha1 "github.com/onmetal/onmetal-api/api/common/v1alpha1" networkingv1alpha1 "github.com/onmetal/onmetal-api/api/networking/v1alpha1" + machinebrokerv1alpha1 "github.com/onmetal/onmetal-api/broker/machinebroker/api/v1alpha1" "github.com/onmetal/onmetal-api/broker/machinebroker/apiutils" ori "github.com/onmetal/onmetal-api/ori/apis/machine/v1alpha1" orimeta "github.com/onmetal/onmetal-api/ori/apis/meta/v1alpha1" "github.com/onmetal/onmetal-api/testutils" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" + corev1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "sigs.k8s.io/controller-runtime/pkg/client" ) @@ -34,10 +37,11 @@ var _ = Describe("CreateNetworkInterface", func() { It("should correctly create a network interface", func() { By("creating a network interface") const ( - ip = "192.168.178.1" - prefix = "192.168.178.1/24" - virtualIP = "10.0.0.1" - networkHandle = "foo" + ip = "192.168.178.1" + prefix = "192.168.178.1/24" + virtualIP = "10.0.0.1" + loadBalancerIP = "10.0.0.2" + networkHandle = "foo" ) res, err := srv.CreateNetworkInterface(ctx, &ori.CreateNetworkInterfaceRequest{ NetworkInterface: &ori.NetworkInterface{ @@ -49,14 +53,28 @@ var _ = Describe("CreateNetworkInterface", func() { Ips: []string{ip}, VirtualIp: &ori.VirtualIPSpec{Ip: virtualIP}, Prefixes: []string{prefix}, + LoadBalancerTargets: []*ori.LoadBalancerTargetSpec{ + { + Ip: loadBalancerIP, + Ports: []*ori.LoadBalancerPort{ + { + Protocol: ori.Protocol_TCP, + Port: 80, + EndPort: 80, + }, + }, + }, + }, }, }, }) Expect(err).NotTo(HaveOccurred()) + networkInterface := res.NetworkInterface + networkInterfaceID := networkInterface.Metadata.Id By("inspecting the kubernetes network interface") k8sNetworkInterface := &networkingv1alpha1.NetworkInterface{} - k8sNetworkInterfaceKey := client.ObjectKey{Namespace: ns.Name, Name: res.NetworkInterface.Metadata.Id} + k8sNetworkInterfaceKey := client.ObjectKey{Namespace: ns.Name, Name: networkInterfaceID} Expect(k8sClient.Get(ctx, k8sNetworkInterfaceKey, k8sNetworkInterface)).To(Succeed()) Expect(k8sNetworkInterface.Spec.IPs).To(Equal([]networkingv1alpha1.IPSource{ @@ -71,7 +89,7 @@ var _ = Describe("CreateNetworkInterface", func() { Expect(k8sClient.Get(ctx, k8sNetworkKey, k8sNetwork)).To(Succeed()) By("inspecting the referenced kubernetes network") - Expect(apiutils.GetDependents(k8sNetwork)).To(ContainElement(res.NetworkInterface.Metadata.Id)) + Expect(apiutils.GetDependents(k8sNetwork)).To(ContainElement(networkInterfaceID)) Expect(k8sNetwork.Spec.Handle).To(Equal(networkHandle)) By("inspecting the virtual ip reference") @@ -86,12 +104,32 @@ var _ = Describe("CreateNetworkInterface", func() { By("inspecting the referenced kubernetes virtual ip") Expect(k8sVirtualIP.Status.IP).To(Equal(commonv1alpha1.MustParseNewIP(virtualIP))) - By("listing all kubernetes alias prefixes") - k8sAliasPrefixList := &networkingv1alpha1.AliasPrefixList{} - Expect(k8sClient.List(ctx, k8sAliasPrefixList, client.InNamespace(ns.Name))).To(Succeed()) + By("listing alias prefixes for network interface") + aliasPrefixes, err := srv.AliasPrefixes().ListByDependent(ctx, networkInterfaceID) + Expect(err).NotTo(HaveOccurred()) + + By("inspecting the alias prefix list") + Expect(aliasPrefixes).To(HaveLen(1)) + aliasPrefix := aliasPrefixes[0] + Expect(aliasPrefix.NetworkHandle).To(Equal(networkHandle)) + Expect(aliasPrefix.Prefix).To(Equal(commonv1alpha1.MustParseIPPrefix(prefix))) + Expect(aliasPrefix.Destinations.Equal(set.New(networkInterfaceID))).To(BeTrue()) - By("inspecting the list of kubernetes alias prefixes") - Expect(k8sAliasPrefixList.Items).ShouldNot(BeEmpty()) + By("listing load balancers for network interface") + loadBalancers, err := srv.LoadBalancers().ListByDependent(ctx, networkInterfaceID) + Expect(err).NotTo(HaveOccurred()) + + By("inspecting the load balancer list") + Expect(loadBalancers).To(HaveLen(1)) + loadBalancer := loadBalancers[0] + Expect(loadBalancer.NetworkHandle).To(Equal(networkHandle)) + Expect(loadBalancer.IP).To(Equal(commonv1alpha1.MustParseIP(loadBalancerIP))) + Expect(loadBalancer.Ports).To(ConsistOf(machinebrokerv1alpha1.LoadBalancerTargetPort{ + Protocol: corev1.ProtocolTCP, + Port: 80, + EndPort: 80, + })) + Expect(loadBalancer.Destinations.Equal(set.New(networkInterfaceID))).To(BeTrue()) }) It("should re-use kubernetes networks and delete them only if no dependents exist", func() { diff --git a/broker/machinebroker/server/networkinterface_list.go b/broker/machinebroker/server/networkinterface_list.go index 5c97df9d8..b9396f353 100644 --- a/broker/machinebroker/server/networkinterface_list.go +++ b/broker/machinebroker/server/networkinterface_list.go @@ -23,6 +23,7 @@ import ( "github.com/onmetal/onmetal-api/broker/common/utils" "github.com/onmetal/onmetal-api/broker/machinebroker/aliasprefixes" machinebrokerv1alpha1 "github.com/onmetal/onmetal-api/broker/machinebroker/api/v1alpha1" + "github.com/onmetal/onmetal-api/broker/machinebroker/loadbalancers" ori "github.com/onmetal/onmetal-api/ori/apis/machine/v1alpha1" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -40,6 +41,16 @@ func (s *Server) buildIDToAliasPrefixesMap(aliasPrefixes []aliasprefixes.AliasPr return res } +func (s *Server) buildIDToLoadBalancersMap(loadBalancers []loadbalancers.LoadBalancer) map[string][]loadbalancers.LoadBalancer { + res := make(map[string][]loadbalancers.LoadBalancer) + for _, loadBalancer := range loadBalancers { + for destination := range loadBalancer.Destinations { + res[destination] = append(res[destination], loadBalancer) + } + } + return res +} + func (s *Server) listAggregateOnmetalNetworkInterfaces(ctx context.Context) ([]AggregateOnmetalNetworkInterface, error) { onmetalNetworkInterfaceList := &networkingv1alpha1.NetworkInterfaceList{} if err := s.listManagedAndCreated(ctx, onmetalNetworkInterfaceList); err != nil { @@ -61,7 +72,13 @@ func (s *Server) listAggregateOnmetalNetworkInterfaces(ctx context.Context) ([]A return nil, fmt.Errorf("error listing onmetal alias prefixes: %w", err) } + onmetalLoadBalancers, err := s.loadBalancers.List(ctx) + if err != nil { + return nil, fmt.Errorf("error listing onmetal load balancers: %w", err) + } + idToAliasPrefixes := s.buildIDToAliasPrefixesMap(onmetalAliasPrefixes) + idToLoadBalancers := s.buildIDToLoadBalancersMap(onmetalLoadBalancers) getNetwork := utils.ObjectSliceToByNameGetter(networkingv1alpha1.Resource("networks"), onmetalNetworkList.Items) getVirtualIP := utils.ObjectSliceToByNameGetter(networkingv1alpha1.Resource("virtualips"), onmetalVirtualIPList.Items) @@ -75,6 +92,9 @@ func (s *Server) listAggregateOnmetalNetworkInterfaces(ctx context.Context) ([]A func() ([]aliasprefixes.AliasPrefix, error) { return idToAliasPrefixes[onmetalNetworkInterface.Name], nil }, + func() ([]loadbalancers.LoadBalancer, error) { + return idToLoadBalancers[onmetalNetworkInterface.Name], nil + }, ) if err != nil { return nil, fmt.Errorf("error assembling onmetal network interface %s: %w", onmetalNetworkInterface.Name, err) @@ -90,6 +110,7 @@ func (s *Server) aggregateOnmetalNetworkInterface( getNetwork func(name string) (*networkingv1alpha1.Network, error), getVirtualIP func(name string) (*networkingv1alpha1.VirtualIP, error), listAliasPrefixes func() ([]aliasprefixes.AliasPrefix, error), + listLoadBalancers func() ([]loadbalancers.LoadBalancer, error), ) (*AggregateOnmetalNetworkInterface, error) { network, err := getNetwork(onmetalNetworkInterface.Spec.NetworkRef.Name) if err != nil { @@ -125,11 +146,29 @@ func (s *Server) aggregateOnmetalNetworkInterface( prefixes = append(prefixes, aliasPrefix.Prefix) } + loadBalancers, err := listLoadBalancers() + if err != nil { + return nil, fmt.Errorf("error listing load balancers: %w", err) + } + + var lbTgts []machinebrokerv1alpha1.LoadBalancerTarget + for _, loadBalancer := range loadBalancers { + if !loadBalancer.Destinations.Has(onmetalNetworkInterface.Name) { + continue + } + + lbTgts = append(lbTgts, machinebrokerv1alpha1.LoadBalancerTarget{ + IP: loadBalancer.IP, + Ports: loadBalancer.Ports, + }) + } + return &AggregateOnmetalNetworkInterface{ - NetworkInterface: onmetalNetworkInterface, - Network: network, - VirtualIP: virtualIP, - Prefixes: prefixes, + NetworkInterface: onmetalNetworkInterface, + Network: network, + VirtualIP: virtualIP, + Prefixes: prefixes, + LoadBalancerTargets: lbTgts, }, nil } @@ -149,6 +188,9 @@ func (s *Server) getAggregateOnmetalNetworkInterface(ctx context.Context, id str func() ([]aliasprefixes.AliasPrefix, error) { return s.aliasPrefixes.ListByDependent(ctx, id) }, + func() ([]loadbalancers.LoadBalancer, error) { + return s.loadBalancers.ListByDependent(ctx, id) + }, ) } diff --git a/broker/machinebroker/server/server.go b/broker/machinebroker/server/server.go index 8fc3e2d7f..674306a72 100644 --- a/broker/machinebroker/server/server.go +++ b/broker/machinebroker/server/server.go @@ -17,6 +17,7 @@ package server import ( "github.com/onmetal/onmetal-api/broker/machinebroker/aliasprefixes" "github.com/onmetal/onmetal-api/broker/machinebroker/cluster" + "github.com/onmetal/onmetal-api/broker/machinebroker/loadbalancers" "github.com/onmetal/onmetal-api/broker/machinebroker/networks" "github.com/onmetal/onmetal-api/ori/apis/machine/v1alpha1" "k8s.io/client-go/rest" @@ -38,6 +39,7 @@ type Server struct { cluster cluster.Cluster networks *networks.Networks aliasPrefixes *aliasprefixes.AliasPrefixes + loadBalancers *loadbalancers.LoadBalancers } type Options struct { @@ -58,6 +60,7 @@ func New(cfg *rest.Config, namespace string, opts Options) (*Server, error) { cluster: c, networks: networks.New(c), aliasPrefixes: aliasprefixes.New(c), + loadBalancers: loadbalancers.New(c), }, nil } @@ -72,3 +75,7 @@ func (s *Server) Networks() *networks.Networks { func (s *Server) AliasPrefixes() *aliasprefixes.AliasPrefixes { return s.aliasPrefixes } + +func (s *Server) LoadBalancers() *loadbalancers.LoadBalancers { + return s.loadBalancers +} diff --git a/ori/apis/machine/v1alpha1/api.pb.go b/ori/apis/machine/v1alpha1/api.pb.go index e0c269d9f..f7659dcba 100644 --- a/ori/apis/machine/v1alpha1/api.pb.go +++ b/ori/apis/machine/v1alpha1/api.pb.go @@ -31,6 +31,34 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +type Protocol int32 + +const ( + Protocol_TCP Protocol = 0 + Protocol_UDP Protocol = 1 + Protocol_SCTP Protocol = 2 +) + +var Protocol_name = map[int32]string{ + 0: "TCP", + 1: "UDP", + 2: "SCTP", +} + +var Protocol_value = map[string]int32{ + "TCP": 0, + "UDP": 1, + "SCTP": 2, +} + +func (x Protocol) String() string { + return proto.EnumName(Protocol_name, int32(x)) +} + +func (Protocol) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{0} +} + type VolumeAttachmentState int32 const ( @@ -56,7 +84,7 @@ func (x VolumeAttachmentState) String() string { } func (VolumeAttachmentState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{0} + return fileDescriptor_00212fb1f9d3bf1c, []int{1} } type NetworkInterfaceAttachmentState int32 @@ -84,7 +112,7 @@ func (x NetworkInterfaceAttachmentState) String() string { } func (NetworkInterfaceAttachmentState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{1} + return fileDescriptor_00212fb1f9d3bf1c, []int{2} } type MachineState int32 @@ -112,7 +140,7 @@ func (x MachineState) String() string { } func (MachineState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{2} + return fileDescriptor_00212fb1f9d3bf1c, []int{3} } type VolumeFilter struct { @@ -433,19 +461,134 @@ func (m *VirtualIPSpec) GetIp() string { return "" } +type LoadBalancerPort struct { + Protocol Protocol `protobuf:"varint,1,opt,name=protocol,proto3,enum=machine.v1alpha1.Protocol" json:"protocol,omitempty"` + Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` + EndPort int32 `protobuf:"varint,3,opt,name=endPort,proto3" json:"endPort,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LoadBalancerPort) Reset() { *m = LoadBalancerPort{} } +func (*LoadBalancerPort) ProtoMessage() {} +func (*LoadBalancerPort) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{6} +} +func (m *LoadBalancerPort) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LoadBalancerPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LoadBalancerPort.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *LoadBalancerPort) XXX_Merge(src proto.Message) { + xxx_messageInfo_LoadBalancerPort.Merge(m, src) +} +func (m *LoadBalancerPort) XXX_Size() int { + return m.Size() +} +func (m *LoadBalancerPort) XXX_DiscardUnknown() { + xxx_messageInfo_LoadBalancerPort.DiscardUnknown(m) +} + +var xxx_messageInfo_LoadBalancerPort proto.InternalMessageInfo + +func (m *LoadBalancerPort) GetProtocol() Protocol { + if m != nil { + return m.Protocol + } + return Protocol_TCP +} + +func (m *LoadBalancerPort) GetPort() int32 { + if m != nil { + return m.Port + } + return 0 +} + +func (m *LoadBalancerPort) GetEndPort() int32 { + if m != nil { + return m.EndPort + } + return 0 +} + +type LoadBalancerTargetSpec struct { + Ip string `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"` + Ports []*LoadBalancerPort `protobuf:"bytes,2,rep,name=ports,proto3" json:"ports,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LoadBalancerTargetSpec) Reset() { *m = LoadBalancerTargetSpec{} } +func (*LoadBalancerTargetSpec) ProtoMessage() {} +func (*LoadBalancerTargetSpec) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{7} +} +func (m *LoadBalancerTargetSpec) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LoadBalancerTargetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LoadBalancerTargetSpec.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *LoadBalancerTargetSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_LoadBalancerTargetSpec.Merge(m, src) +} +func (m *LoadBalancerTargetSpec) XXX_Size() int { + return m.Size() +} +func (m *LoadBalancerTargetSpec) XXX_DiscardUnknown() { + xxx_messageInfo_LoadBalancerTargetSpec.DiscardUnknown(m) +} + +var xxx_messageInfo_LoadBalancerTargetSpec proto.InternalMessageInfo + +func (m *LoadBalancerTargetSpec) GetIp() string { + if m != nil { + return m.Ip + } + return "" +} + +func (m *LoadBalancerTargetSpec) GetPorts() []*LoadBalancerPort { + if m != nil { + return m.Ports + } + return nil +} + type NetworkInterfaceSpec struct { - Network *NetworkSpec `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"` - Ips []string `protobuf:"bytes,2,rep,name=ips,proto3" json:"ips,omitempty"` - VirtualIp *VirtualIPSpec `protobuf:"bytes,3,opt,name=virtual_ip,json=virtualIp,proto3" json:"virtual_ip,omitempty"` - Prefixes []string `protobuf:"bytes,4,rep,name=prefixes,proto3" json:"prefixes,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Network *NetworkSpec `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"` + Ips []string `protobuf:"bytes,2,rep,name=ips,proto3" json:"ips,omitempty"` + VirtualIp *VirtualIPSpec `protobuf:"bytes,3,opt,name=virtual_ip,json=virtualIp,proto3" json:"virtual_ip,omitempty"` + Prefixes []string `protobuf:"bytes,4,rep,name=prefixes,proto3" json:"prefixes,omitempty"` + LoadBalancerTargets []*LoadBalancerTargetSpec `protobuf:"bytes,5,rep,name=load_balancer_targets,json=loadBalancerTargets,proto3" json:"load_balancer_targets,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *NetworkInterfaceSpec) Reset() { *m = NetworkInterfaceSpec{} } func (*NetworkInterfaceSpec) ProtoMessage() {} func (*NetworkInterfaceSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{6} + return fileDescriptor_00212fb1f9d3bf1c, []int{8} } func (m *NetworkInterfaceSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -502,6 +645,13 @@ func (m *NetworkInterfaceSpec) GetPrefixes() []string { return nil } +func (m *NetworkInterfaceSpec) GetLoadBalancerTargets() []*LoadBalancerTargetSpec { + if m != nil { + return m.LoadBalancerTargets + } + return nil +} + type NetworkInterface struct { Metadata *v1alpha1.ObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` Spec *NetworkInterfaceSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` @@ -512,7 +662,7 @@ type NetworkInterface struct { func (m *NetworkInterface) Reset() { *m = NetworkInterface{} } func (*NetworkInterface) ProtoMessage() {} func (*NetworkInterface) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{7} + return fileDescriptor_00212fb1f9d3bf1c, []int{9} } func (m *NetworkInterface) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -564,7 +714,7 @@ type IgnitionSpec struct { func (m *IgnitionSpec) Reset() { *m = IgnitionSpec{} } func (*IgnitionSpec) ProtoMessage() {} func (*IgnitionSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{8} + return fileDescriptor_00212fb1f9d3bf1c, []int{10} } func (m *IgnitionSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -610,7 +760,7 @@ type MachineFilter struct { func (m *MachineFilter) Reset() { *m = MachineFilter{} } func (*MachineFilter) ProtoMessage() {} func (*MachineFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{9} + return fileDescriptor_00212fb1f9d3bf1c, []int{11} } func (m *MachineFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -663,7 +813,7 @@ type MachineClassCapabilities struct { func (m *MachineClassCapabilities) Reset() { *m = MachineClassCapabilities{} } func (*MachineClassCapabilities) ProtoMessage() {} func (*MachineClassCapabilities) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{10} + return fileDescriptor_00212fb1f9d3bf1c, []int{12} } func (m *MachineClassCapabilities) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -717,7 +867,7 @@ type Machine struct { func (m *Machine) Reset() { *m = Machine{} } func (*Machine) ProtoMessage() {} func (*Machine) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{11} + return fileDescriptor_00212fb1f9d3bf1c, []int{13} } func (m *Machine) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -776,7 +926,7 @@ type ImageSpec struct { func (m *ImageSpec) Reset() { *m = ImageSpec{} } func (*ImageSpec) ProtoMessage() {} func (*ImageSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{12} + return fileDescriptor_00212fb1f9d3bf1c, []int{14} } func (m *ImageSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -821,7 +971,7 @@ type EmptyDiskSpec struct { func (m *EmptyDiskSpec) Reset() { *m = EmptyDiskSpec{} } func (*EmptyDiskSpec) ProtoMessage() {} func (*EmptyDiskSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{13} + return fileDescriptor_00212fb1f9d3bf1c, []int{15} } func (m *EmptyDiskSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -869,7 +1019,7 @@ type VolumeAttachment struct { func (m *VolumeAttachment) Reset() { *m = VolumeAttachment{} } func (*VolumeAttachment) ProtoMessage() {} func (*VolumeAttachment) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{14} + return fileDescriptor_00212fb1f9d3bf1c, []int{16} } func (m *VolumeAttachment) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -936,7 +1086,7 @@ type NetworkInterfaceAttachment struct { func (m *NetworkInterfaceAttachment) Reset() { *m = NetworkInterfaceAttachment{} } func (*NetworkInterfaceAttachment) ProtoMessage() {} func (*NetworkInterfaceAttachment) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{15} + return fileDescriptor_00212fb1f9d3bf1c, []int{17} } func (m *NetworkInterfaceAttachment) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -992,7 +1142,7 @@ type MachineSpec struct { func (m *MachineSpec) Reset() { *m = MachineSpec{} } func (*MachineSpec) ProtoMessage() {} func (*MachineSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{16} + return fileDescriptor_00212fb1f9d3bf1c, []int{18} } func (m *MachineSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1069,7 +1219,7 @@ type MachineStatus struct { func (m *MachineStatus) Reset() { *m = MachineStatus{} } func (*MachineStatus) ProtoMessage() {} func (*MachineStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{17} + return fileDescriptor_00212fb1f9d3bf1c, []int{19} } func (m *MachineStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1144,7 +1294,7 @@ type VolumeAttachmentStatus struct { func (m *VolumeAttachmentStatus) Reset() { *m = VolumeAttachmentStatus{} } func (*VolumeAttachmentStatus) ProtoMessage() {} func (*VolumeAttachmentStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{18} + return fileDescriptor_00212fb1f9d3bf1c, []int{20} } func (m *VolumeAttachmentStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1205,7 +1355,7 @@ type NetworkInterfaceAttachmentStatus struct { func (m *NetworkInterfaceAttachmentStatus) Reset() { *m = NetworkInterfaceAttachmentStatus{} } func (*NetworkInterfaceAttachmentStatus) ProtoMessage() {} func (*NetworkInterfaceAttachmentStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{19} + return fileDescriptor_00212fb1f9d3bf1c, []int{21} } func (m *NetworkInterfaceAttachmentStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1265,7 +1415,7 @@ type MachineClass struct { func (m *MachineClass) Reset() { *m = MachineClass{} } func (*MachineClass) ProtoMessage() {} func (*MachineClass) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{20} + return fileDescriptor_00212fb1f9d3bf1c, []int{22} } func (m *MachineClass) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1317,7 +1467,7 @@ type ListMachinesRequest struct { func (m *ListMachinesRequest) Reset() { *m = ListMachinesRequest{} } func (*ListMachinesRequest) ProtoMessage() {} func (*ListMachinesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{21} + return fileDescriptor_00212fb1f9d3bf1c, []int{23} } func (m *ListMachinesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1362,7 +1512,7 @@ type ListMachinesResponse struct { func (m *ListMachinesResponse) Reset() { *m = ListMachinesResponse{} } func (*ListMachinesResponse) ProtoMessage() {} func (*ListMachinesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{22} + return fileDescriptor_00212fb1f9d3bf1c, []int{24} } func (m *ListMachinesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1407,7 +1557,7 @@ type CreateMachineRequest struct { func (m *CreateMachineRequest) Reset() { *m = CreateMachineRequest{} } func (*CreateMachineRequest) ProtoMessage() {} func (*CreateMachineRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{23} + return fileDescriptor_00212fb1f9d3bf1c, []int{25} } func (m *CreateMachineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1452,7 +1602,7 @@ type CreateMachineResponse struct { func (m *CreateMachineResponse) Reset() { *m = CreateMachineResponse{} } func (*CreateMachineResponse) ProtoMessage() {} func (*CreateMachineResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{24} + return fileDescriptor_00212fb1f9d3bf1c, []int{26} } func (m *CreateMachineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1497,7 +1647,7 @@ type DeleteMachineRequest struct { func (m *DeleteMachineRequest) Reset() { *m = DeleteMachineRequest{} } func (*DeleteMachineRequest) ProtoMessage() {} func (*DeleteMachineRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{25} + return fileDescriptor_00212fb1f9d3bf1c, []int{27} } func (m *DeleteMachineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1541,7 +1691,7 @@ type DeleteMachineResponse struct { func (m *DeleteMachineResponse) Reset() { *m = DeleteMachineResponse{} } func (*DeleteMachineResponse) ProtoMessage() {} func (*DeleteMachineResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{26} + return fileDescriptor_00212fb1f9d3bf1c, []int{28} } func (m *DeleteMachineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1580,7 +1730,7 @@ type UpdateMachineAnnotationsRequest struct { func (m *UpdateMachineAnnotationsRequest) Reset() { *m = UpdateMachineAnnotationsRequest{} } func (*UpdateMachineAnnotationsRequest) ProtoMessage() {} func (*UpdateMachineAnnotationsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{27} + return fileDescriptor_00212fb1f9d3bf1c, []int{29} } func (m *UpdateMachineAnnotationsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1631,7 +1781,7 @@ type UpdateMachineAnnotationsResponse struct { func (m *UpdateMachineAnnotationsResponse) Reset() { *m = UpdateMachineAnnotationsResponse{} } func (*UpdateMachineAnnotationsResponse) ProtoMessage() {} func (*UpdateMachineAnnotationsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{28} + return fileDescriptor_00212fb1f9d3bf1c, []int{30} } func (m *UpdateMachineAnnotationsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1670,7 +1820,7 @@ type CreateVolumeAttachmentRequest struct { func (m *CreateVolumeAttachmentRequest) Reset() { *m = CreateVolumeAttachmentRequest{} } func (*CreateVolumeAttachmentRequest) ProtoMessage() {} func (*CreateVolumeAttachmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{29} + return fileDescriptor_00212fb1f9d3bf1c, []int{31} } func (m *CreateVolumeAttachmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1721,7 +1871,7 @@ type CreateVolumeAttachmentResponse struct { func (m *CreateVolumeAttachmentResponse) Reset() { *m = CreateVolumeAttachmentResponse{} } func (*CreateVolumeAttachmentResponse) ProtoMessage() {} func (*CreateVolumeAttachmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{30} + return fileDescriptor_00212fb1f9d3bf1c, []int{32} } func (m *CreateVolumeAttachmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1760,7 +1910,7 @@ type DeleteVolumeAttachmentRequest struct { func (m *DeleteVolumeAttachmentRequest) Reset() { *m = DeleteVolumeAttachmentRequest{} } func (*DeleteVolumeAttachmentRequest) ProtoMessage() {} func (*DeleteVolumeAttachmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{31} + return fileDescriptor_00212fb1f9d3bf1c, []int{33} } func (m *DeleteVolumeAttachmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1811,7 +1961,7 @@ type DeleteVolumeAttachmentResponse struct { func (m *DeleteVolumeAttachmentResponse) Reset() { *m = DeleteVolumeAttachmentResponse{} } func (*DeleteVolumeAttachmentResponse) ProtoMessage() {} func (*DeleteVolumeAttachmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{32} + return fileDescriptor_00212fb1f9d3bf1c, []int{34} } func (m *DeleteVolumeAttachmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1852,7 +2002,7 @@ func (m *CreateNetworkInterfaceAttachmentRequest) Reset() { } func (*CreateNetworkInterfaceAttachmentRequest) ProtoMessage() {} func (*CreateNetworkInterfaceAttachmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{33} + return fileDescriptor_00212fb1f9d3bf1c, []int{35} } func (m *CreateNetworkInterfaceAttachmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1905,7 +2055,7 @@ func (m *CreateNetworkInterfaceAttachmentResponse) Reset() { } func (*CreateNetworkInterfaceAttachmentResponse) ProtoMessage() {} func (*CreateNetworkInterfaceAttachmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{34} + return fileDescriptor_00212fb1f9d3bf1c, []int{36} } func (m *CreateNetworkInterfaceAttachmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1946,7 +2096,7 @@ func (m *DeleteNetworkInterfaceAttachmentRequest) Reset() { } func (*DeleteNetworkInterfaceAttachmentRequest) ProtoMessage() {} func (*DeleteNetworkInterfaceAttachmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{35} + return fileDescriptor_00212fb1f9d3bf1c, []int{37} } func (m *DeleteNetworkInterfaceAttachmentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1999,7 +2149,7 @@ func (m *DeleteNetworkInterfaceAttachmentResponse) Reset() { } func (*DeleteNetworkInterfaceAttachmentResponse) ProtoMessage() {} func (*DeleteNetworkInterfaceAttachmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{36} + return fileDescriptor_00212fb1f9d3bf1c, []int{38} } func (m *DeleteNetworkInterfaceAttachmentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2037,7 +2187,7 @@ type ListVolumesRequest struct { func (m *ListVolumesRequest) Reset() { *m = ListVolumesRequest{} } func (*ListVolumesRequest) ProtoMessage() {} func (*ListVolumesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{37} + return fileDescriptor_00212fb1f9d3bf1c, []int{39} } func (m *ListVolumesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2082,7 +2232,7 @@ type ListVolumesResponse struct { func (m *ListVolumesResponse) Reset() { *m = ListVolumesResponse{} } func (*ListVolumesResponse) ProtoMessage() {} func (*ListVolumesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{38} + return fileDescriptor_00212fb1f9d3bf1c, []int{40} } func (m *ListVolumesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2127,7 +2277,7 @@ type CreateVolumeRequest struct { func (m *CreateVolumeRequest) Reset() { *m = CreateVolumeRequest{} } func (*CreateVolumeRequest) ProtoMessage() {} func (*CreateVolumeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{39} + return fileDescriptor_00212fb1f9d3bf1c, []int{41} } func (m *CreateVolumeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2172,7 +2322,7 @@ type CreateVolumeResponse struct { func (m *CreateVolumeResponse) Reset() { *m = CreateVolumeResponse{} } func (*CreateVolumeResponse) ProtoMessage() {} func (*CreateVolumeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{40} + return fileDescriptor_00212fb1f9d3bf1c, []int{42} } func (m *CreateVolumeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2217,7 +2367,7 @@ type DeleteVolumeRequest struct { func (m *DeleteVolumeRequest) Reset() { *m = DeleteVolumeRequest{} } func (*DeleteVolumeRequest) ProtoMessage() {} func (*DeleteVolumeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{41} + return fileDescriptor_00212fb1f9d3bf1c, []int{43} } func (m *DeleteVolumeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2261,7 +2411,7 @@ type DeleteVolumeResponse struct { func (m *DeleteVolumeResponse) Reset() { *m = DeleteVolumeResponse{} } func (*DeleteVolumeResponse) ProtoMessage() {} func (*DeleteVolumeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{42} + return fileDescriptor_00212fb1f9d3bf1c, []int{44} } func (m *DeleteVolumeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2299,7 +2449,7 @@ type ListNetworkInterfacesRequest struct { func (m *ListNetworkInterfacesRequest) Reset() { *m = ListNetworkInterfacesRequest{} } func (*ListNetworkInterfacesRequest) ProtoMessage() {} func (*ListNetworkInterfacesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{43} + return fileDescriptor_00212fb1f9d3bf1c, []int{45} } func (m *ListNetworkInterfacesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2344,7 +2494,7 @@ type ListNetworkInterfacesResponse struct { func (m *ListNetworkInterfacesResponse) Reset() { *m = ListNetworkInterfacesResponse{} } func (*ListNetworkInterfacesResponse) ProtoMessage() {} func (*ListNetworkInterfacesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{44} + return fileDescriptor_00212fb1f9d3bf1c, []int{46} } func (m *ListNetworkInterfacesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2389,7 +2539,7 @@ type CreateNetworkInterfaceRequest struct { func (m *CreateNetworkInterfaceRequest) Reset() { *m = CreateNetworkInterfaceRequest{} } func (*CreateNetworkInterfaceRequest) ProtoMessage() {} func (*CreateNetworkInterfaceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{45} + return fileDescriptor_00212fb1f9d3bf1c, []int{47} } func (m *CreateNetworkInterfaceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2434,7 +2584,7 @@ type CreateNetworkInterfaceResponse struct { func (m *CreateNetworkInterfaceResponse) Reset() { *m = CreateNetworkInterfaceResponse{} } func (*CreateNetworkInterfaceResponse) ProtoMessage() {} func (*CreateNetworkInterfaceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{46} + return fileDescriptor_00212fb1f9d3bf1c, []int{48} } func (m *CreateNetworkInterfaceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2479,7 +2629,7 @@ type DeleteNetworkInterfaceRequest struct { func (m *DeleteNetworkInterfaceRequest) Reset() { *m = DeleteNetworkInterfaceRequest{} } func (*DeleteNetworkInterfaceRequest) ProtoMessage() {} func (*DeleteNetworkInterfaceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{47} + return fileDescriptor_00212fb1f9d3bf1c, []int{49} } func (m *DeleteNetworkInterfaceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2523,7 +2673,7 @@ type DeleteNetworkInterfaceResponse struct { func (m *DeleteNetworkInterfaceResponse) Reset() { *m = DeleteNetworkInterfaceResponse{} } func (*DeleteNetworkInterfaceResponse) ProtoMessage() {} func (*DeleteNetworkInterfaceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{48} + return fileDescriptor_00212fb1f9d3bf1c, []int{50} } func (m *DeleteNetworkInterfaceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2562,7 +2712,7 @@ type UpdateNetworkInterfaceIPsRequest struct { func (m *UpdateNetworkInterfaceIPsRequest) Reset() { *m = UpdateNetworkInterfaceIPsRequest{} } func (*UpdateNetworkInterfaceIPsRequest) ProtoMessage() {} func (*UpdateNetworkInterfaceIPsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{49} + return fileDescriptor_00212fb1f9d3bf1c, []int{51} } func (m *UpdateNetworkInterfaceIPsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2613,7 +2763,7 @@ type UpdateNetworkInterfaceIPsResponse struct { func (m *UpdateNetworkInterfaceIPsResponse) Reset() { *m = UpdateNetworkInterfaceIPsResponse{} } func (*UpdateNetworkInterfaceIPsResponse) ProtoMessage() {} func (*UpdateNetworkInterfaceIPsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{50} + return fileDescriptor_00212fb1f9d3bf1c, []int{52} } func (m *UpdateNetworkInterfaceIPsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2654,7 +2804,7 @@ func (m *CreateNetworkInterfaceVirtualIPRequest) Reset() { } func (*CreateNetworkInterfaceVirtualIPRequest) ProtoMessage() {} func (*CreateNetworkInterfaceVirtualIPRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{51} + return fileDescriptor_00212fb1f9d3bf1c, []int{53} } func (m *CreateNetworkInterfaceVirtualIPRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2707,7 +2857,7 @@ func (m *CreateNetworkInterfaceVirtualIPResponse) Reset() { } func (*CreateNetworkInterfaceVirtualIPResponse) ProtoMessage() {} func (*CreateNetworkInterfaceVirtualIPResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{52} + return fileDescriptor_00212fb1f9d3bf1c, []int{54} } func (m *CreateNetworkInterfaceVirtualIPResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2748,7 +2898,7 @@ func (m *UpdateNetworkInterfaceVirtualIPRequest) Reset() { } func (*UpdateNetworkInterfaceVirtualIPRequest) ProtoMessage() {} func (*UpdateNetworkInterfaceVirtualIPRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{53} + return fileDescriptor_00212fb1f9d3bf1c, []int{55} } func (m *UpdateNetworkInterfaceVirtualIPRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2801,7 +2951,7 @@ func (m *UpdateNetworkInterfaceVirtualIPResponse) Reset() { } func (*UpdateNetworkInterfaceVirtualIPResponse) ProtoMessage() {} func (*UpdateNetworkInterfaceVirtualIPResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{54} + return fileDescriptor_00212fb1f9d3bf1c, []int{56} } func (m *UpdateNetworkInterfaceVirtualIPResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2840,7 +2990,7 @@ type CreateNetworkInterfacePrefixRequest struct { func (m *CreateNetworkInterfacePrefixRequest) Reset() { *m = CreateNetworkInterfacePrefixRequest{} } func (*CreateNetworkInterfacePrefixRequest) ProtoMessage() {} func (*CreateNetworkInterfacePrefixRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{55} + return fileDescriptor_00212fb1f9d3bf1c, []int{57} } func (m *CreateNetworkInterfacePrefixRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2891,7 +3041,7 @@ type CreateNetworkInterfacePrefixResponse struct { func (m *CreateNetworkInterfacePrefixResponse) Reset() { *m = CreateNetworkInterfacePrefixResponse{} } func (*CreateNetworkInterfacePrefixResponse) ProtoMessage() {} func (*CreateNetworkInterfacePrefixResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{56} + return fileDescriptor_00212fb1f9d3bf1c, []int{58} } func (m *CreateNetworkInterfacePrefixResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2930,7 +3080,7 @@ type DeleteNetworkInterfacePrefixRequest struct { func (m *DeleteNetworkInterfacePrefixRequest) Reset() { *m = DeleteNetworkInterfacePrefixRequest{} } func (*DeleteNetworkInterfacePrefixRequest) ProtoMessage() {} func (*DeleteNetworkInterfacePrefixRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{57} + return fileDescriptor_00212fb1f9d3bf1c, []int{59} } func (m *DeleteNetworkInterfacePrefixRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2981,7 +3131,7 @@ type DeleteNetworkInterfacePrefixResponse struct { func (m *DeleteNetworkInterfacePrefixResponse) Reset() { *m = DeleteNetworkInterfacePrefixResponse{} } func (*DeleteNetworkInterfacePrefixResponse) ProtoMessage() {} func (*DeleteNetworkInterfacePrefixResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{58} + return fileDescriptor_00212fb1f9d3bf1c, []int{60} } func (m *DeleteNetworkInterfacePrefixResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3021,7 +3171,7 @@ func (m *DeleteNetworkInterfaceVirtualIPRequest) Reset() { } func (*DeleteNetworkInterfaceVirtualIPRequest) ProtoMessage() {} func (*DeleteNetworkInterfaceVirtualIPRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{59} + return fileDescriptor_00212fb1f9d3bf1c, []int{61} } func (m *DeleteNetworkInterfaceVirtualIPRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3067,7 +3217,7 @@ func (m *DeleteNetworkInterfaceVirtualIPResponse) Reset() { } func (*DeleteNetworkInterfaceVirtualIPResponse) ProtoMessage() {} func (*DeleteNetworkInterfaceVirtualIPResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{60} + return fileDescriptor_00212fb1f9d3bf1c, []int{62} } func (m *DeleteNetworkInterfaceVirtualIPResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3104,7 +3254,7 @@ type ListMachineClassesRequest struct { func (m *ListMachineClassesRequest) Reset() { *m = ListMachineClassesRequest{} } func (*ListMachineClassesRequest) ProtoMessage() {} func (*ListMachineClassesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{61} + return fileDescriptor_00212fb1f9d3bf1c, []int{63} } func (m *ListMachineClassesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3142,7 +3292,7 @@ type ListMachineClassesResponse struct { func (m *ListMachineClassesResponse) Reset() { *m = ListMachineClassesResponse{} } func (*ListMachineClassesResponse) ProtoMessage() {} func (*ListMachineClassesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{62} + return fileDescriptor_00212fb1f9d3bf1c, []int{64} } func (m *ListMachineClassesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3179,6 +3329,7 @@ func (m *ListMachineClassesResponse) GetMachineClasses() []*MachineClass { } func init() { + proto.RegisterEnum("machine.v1alpha1.Protocol", Protocol_name, Protocol_value) proto.RegisterEnum("machine.v1alpha1.VolumeAttachmentState", VolumeAttachmentState_name, VolumeAttachmentState_value) proto.RegisterEnum("machine.v1alpha1.NetworkInterfaceAttachmentState", NetworkInterfaceAttachmentState_name, NetworkInterfaceAttachmentState_value) proto.RegisterEnum("machine.v1alpha1.MachineState", MachineState_name, MachineState_value) @@ -3192,6 +3343,8 @@ func init() { proto.RegisterMapType((map[string]string)(nil), "machine.v1alpha1.NetworkInterfaceFilter.LabelSelectorEntry") proto.RegisterType((*NetworkSpec)(nil), "machine.v1alpha1.NetworkSpec") proto.RegisterType((*VirtualIPSpec)(nil), "machine.v1alpha1.VirtualIPSpec") + proto.RegisterType((*LoadBalancerPort)(nil), "machine.v1alpha1.LoadBalancerPort") + proto.RegisterType((*LoadBalancerTargetSpec)(nil), "machine.v1alpha1.LoadBalancerTargetSpec") proto.RegisterType((*NetworkInterfaceSpec)(nil), "machine.v1alpha1.NetworkInterfaceSpec") proto.RegisterType((*NetworkInterface)(nil), "machine.v1alpha1.NetworkInterface") proto.RegisterType((*IgnitionSpec)(nil), "machine.v1alpha1.IgnitionSpec") @@ -3256,147 +3409,156 @@ func init() { func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) } var fileDescriptor_00212fb1f9d3bf1c = []byte{ - // 2227 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xdb, 0xc6, - 0x15, 0x17, 0x28, 0x59, 0x16, 0x1f, 0x29, 0x59, 0x5e, 0x7d, 0x94, 0x86, 0x4d, 0x4a, 0x86, 0x6d, - 0x59, 0x51, 0x13, 0xd2, 0xa2, 0xeb, 0xc4, 0x56, 0x9b, 0x34, 0xb2, 0xc4, 0xc8, 0x9c, 0x48, 0x94, - 0x03, 0xc9, 0x6e, 0x93, 0x7a, 0x86, 0x05, 0xc9, 0x95, 0x84, 0x9a, 0x1f, 0x08, 0x00, 0xaa, 0x51, - 0x32, 0x99, 0x69, 0x67, 0x7a, 0xe9, 0xa1, 0x33, 0x39, 0xf5, 0xd0, 0x9c, 0x3a, 0x3d, 0x77, 0xa6, - 0xd7, 0x66, 0xda, 0x7b, 0x4e, 0x9d, 0xde, 0xda, 0x63, 0xe3, 0xce, 0xf4, 0xd8, 0xbf, 0xa1, 0x83, - 0xdd, 0x05, 0x88, 0x8f, 0x5d, 0x02, 0x94, 0x5b, 0x4f, 0x4f, 0x26, 0x16, 0xef, 0xe3, 0xf7, 0xde, - 0xbe, 0xf7, 0x76, 0x7f, 0xb0, 0x20, 0xad, 0x19, 0x7a, 0xd1, 0x30, 0x7b, 0x76, 0x0f, 0xcd, 0x76, - 0xb4, 0xe6, 0x89, 0xde, 0xc5, 0xc5, 0xd3, 0x75, 0xad, 0x6d, 0x9c, 0x68, 0xeb, 0xf2, 0x1b, 0xc7, - 0xba, 0x7d, 0xd2, 0x6f, 0x14, 0x9b, 0xbd, 0x4e, 0xe9, 0xb8, 0x77, 0xdc, 0x2b, 0x11, 0xc1, 0x46, - 0xff, 0x88, 0x3c, 0x91, 0x07, 0xf2, 0x8b, 0x1a, 0x90, 0xbf, 0xef, 0x13, 0xef, 0x75, 0x3b, 0xd8, - 0xd6, 0xda, 0xee, 0xbf, 0x6f, 0x68, 0x86, 0x5e, 0xea, 0x99, 0x7a, 0x49, 0x33, 0x74, 0xab, 0xe4, - 0x2c, 0x95, 0x5c, 0x2f, 0x25, 0x0f, 0x81, 0xf2, 0x95, 0x04, 0xd9, 0xa7, 0xbd, 0x76, 0xbf, 0x83, - 0xdf, 0xd3, 0xdb, 0x36, 0x36, 0xd1, 0x0c, 0xa4, 0xf4, 0x56, 0x4e, 0x5a, 0x96, 0x56, 0xd3, 0x6a, - 0x4a, 0x6f, 0xa1, 0x1f, 0xc2, 0x4c, 0x5b, 0x6b, 0xe0, 0x76, 0xdd, 0xc2, 0x6d, 0xdc, 0xb4, 0x7b, - 0x66, 0x2e, 0xb5, 0x3c, 0xbe, 0x9a, 0x29, 0xaf, 0x17, 0xc3, 0xd8, 0x8b, 0x7e, 0x3b, 0xc5, 0x5d, - 0x47, 0xe9, 0x80, 0xe9, 0x54, 0xba, 0xb6, 0x79, 0xa6, 0x4e, 0xb7, 0xfd, 0x6b, 0xf2, 0xbb, 0x80, - 0xa2, 0x42, 0x68, 0x16, 0xc6, 0x9f, 0xe3, 0x33, 0x06, 0xc0, 0xf9, 0x89, 0xe6, 0xe1, 0xc2, 0xa9, - 0xd6, 0xee, 0xe3, 0x5c, 0x8a, 0xac, 0xd1, 0x87, 0x8d, 0xd4, 0x7d, 0x49, 0xf9, 0x5b, 0x0a, 0x80, - 0x3a, 0x3d, 0x30, 0x70, 0x13, 0x2d, 0xc2, 0x64, 0xcb, 0xd4, 0x4f, 0xb1, 0xc9, 0xb4, 0xd9, 0x93, - 0xb3, 0x7e, 0xa2, 0x75, 0x5b, 0x6d, 0xd7, 0x02, 0x7b, 0x42, 0xbb, 0x00, 0x9a, 0x6d, 0x9b, 0x7a, - 0xa3, 0x6f, 0x63, 0x2b, 0x37, 0x4e, 0xc2, 0x7a, 0x5d, 0x14, 0x96, 0xe3, 0xa1, 0xb8, 0xe9, 0x89, - 0xd3, 0x88, 0x7c, 0xfa, 0x68, 0x0f, 0x32, 0x16, 0x6e, 0x9a, 0xd8, 0xae, 0xb7, 0x34, 0x5b, 0xcb, - 0x4d, 0x24, 0x30, 0x77, 0x40, 0xe4, 0xb7, 0x35, 0x5b, 0x63, 0xe6, 0x2c, 0x6f, 0x41, 0x7e, 0x1b, - 0x2e, 0x85, 0xbc, 0x8d, 0x92, 0x1a, 0x47, 0x3d, 0x64, 0x3d, 0x4e, 0x3d, 0xeb, 0xcf, 0x6c, 0x1f, - 0x26, 0x29, 0x4e, 0xf4, 0x00, 0xa6, 0x9c, 0xda, 0x21, 0x31, 0x39, 0xaa, 0x99, 0x72, 0xbe, 0xe8, - 0x2c, 0x0c, 0x02, 0xda, 0x6f, 0xfc, 0x04, 0x37, 0xed, 0x3d, 0x26, 0xa4, 0x7a, 0xe2, 0xe8, 0x0e, - 0x4c, 0x58, 0x06, 0x6e, 0x12, 0xeb, 0x99, 0xf2, 0xb5, 0x61, 0xa9, 0x50, 0x89, 0xa4, 0xf2, 0x17, - 0x09, 0x16, 0x6b, 0xd8, 0xfe, 0x69, 0xcf, 0x7c, 0x5e, 0xed, 0xda, 0xd8, 0x3c, 0xd2, 0x9a, 0xa2, - 0xba, 0x6c, 0x08, 0xea, 0xf2, 0xbb, 0x51, 0x37, 0x7c, 0x8b, 0xaf, 0xa4, 0x42, 0x6f, 0x41, 0x86, - 0x79, 0x77, 0x2b, 0x94, 0x55, 0xa2, 0xe4, 0xaf, 0x44, 0x65, 0x09, 0xa6, 0x9f, 0xea, 0xa6, 0xdd, - 0xd7, 0xda, 0xd5, 0xc7, 0x44, 0xd0, 0x89, 0xd6, 0xf0, 0xa2, 0x35, 0x94, 0x3f, 0x4b, 0x30, 0x1f, - 0x0e, 0x83, 0x08, 0xbe, 0x05, 0x17, 0xbb, 0x74, 0x7d, 0xb0, 0x3b, 0x82, 0xf8, 0x49, 0x9e, 0x5d, - 0x69, 0x27, 0x0a, 0xdd, 0xb0, 0x48, 0xd2, 0xd2, 0xaa, 0xf3, 0x13, 0xbd, 0x03, 0x70, 0x4a, 0x41, - 0xd4, 0x75, 0x23, 0x37, 0x4e, 0xac, 0x2d, 0x71, 0x36, 0xcd, 0x0f, 0x54, 0x4d, 0x33, 0x95, 0xaa, - 0x81, 0x64, 0x98, 0x32, 0x4c, 0x7c, 0xa4, 0x7f, 0x82, 0x2d, 0x52, 0xfd, 0x69, 0xd5, 0x7b, 0x56, - 0x7e, 0x29, 0xc1, 0x6c, 0x18, 0xff, 0xcb, 0x94, 0xd6, 0x46, 0xa0, 0xb4, 0x56, 0xe2, 0xf7, 0xdc, - 0x57, 0x64, 0x0a, 0x64, 0xab, 0xc7, 0x5d, 0xdd, 0xd6, 0x7b, 0x5d, 0x92, 0x42, 0x04, 0x13, 0x1e, - 0x84, 0xac, 0x4a, 0x7e, 0x2b, 0x7f, 0x92, 0x60, 0x7a, 0x8f, 0xda, 0x14, 0xd4, 0xdf, 0x87, 0x82, - 0xfa, 0x2b, 0x47, 0xb1, 0x04, 0x0c, 0xbd, 0x92, 0xb2, 0x7b, 0x06, 0x39, 0xe6, 0x74, 0xab, 0xad, - 0x59, 0xd6, 0x96, 0x66, 0x68, 0x0d, 0xbd, 0xad, 0xdb, 0x3a, 0xb6, 0x50, 0x1e, 0xa0, 0x69, 0xf4, - 0xeb, 0x1d, 0xbd, 0xdd, 0xd6, 0x2d, 0x62, 0x6e, 0x5c, 0x4d, 0x37, 0x8d, 0xfe, 0x1e, 0x59, 0x40, - 0xd7, 0x21, 0xdb, 0xc1, 0x9d, 0x9e, 0x79, 0x56, 0x6f, 0x9c, 0x39, 0x63, 0xd1, 0xb1, 0x3d, 0xa1, - 0x66, 0xe8, 0xda, 0x43, 0x67, 0x49, 0xf9, 0x83, 0x04, 0x17, 0x99, 0xf9, 0x97, 0xd9, 0xc3, 0xf5, - 0xc0, 0x1e, 0xe6, 0x85, 0x79, 0x1b, 0x6c, 0x1d, 0x7a, 0x0b, 0x26, 0x2d, 0x5b, 0xb3, 0xfb, 0x96, - 0xb8, 0x3c, 0x5d, 0x25, 0x22, 0xa6, 0x32, 0x71, 0xe5, 0x3a, 0xa4, 0xab, 0x1d, 0xed, 0x98, 0xf6, - 0xcc, 0x3c, 0x5c, 0xd0, 0x9d, 0x07, 0x96, 0x4b, 0xfa, 0xa0, 0x14, 0x61, 0xba, 0xd2, 0x31, 0xec, - 0xb3, 0x6d, 0xdd, 0xa2, 0xcd, 0x9a, 0x07, 0xb0, 0xf4, 0x4f, 0x31, 0xcb, 0x83, 0x44, 0xf2, 0x90, - 0x76, 0x56, 0x68, 0x16, 0xbe, 0x94, 0x60, 0x96, 0x0e, 0xb0, 0x4d, 0xdb, 0xd6, 0x9a, 0x27, 0x1d, - 0xdc, 0xb5, 0x9d, 0x5a, 0xea, 0x6a, 0x1d, 0xd7, 0x32, 0xf9, 0x4d, 0x8e, 0x25, 0x7c, 0xaa, 0x37, - 0xbd, 0xe3, 0x87, 0x3e, 0xa1, 0xab, 0x90, 0x3e, 0x25, 0xfa, 0x75, 0xbd, 0x45, 0xe2, 0x49, 0xab, - 0x53, 0x74, 0xa1, 0xda, 0x72, 0x9a, 0x11, 0x3b, 0x68, 0xea, 0x2d, 0xdd, 0x7a, 0x9e, 0x9b, 0x10, - 0x45, 0x1b, 0x40, 0xac, 0xa6, 0xb1, 0xfb, 0xa8, 0x34, 0x40, 0x0e, 0xb7, 0x40, 0x0c, 0xcc, 0x3b, - 0x30, 0xcf, 0x66, 0x43, 0x5d, 0x77, 0x55, 0x1c, 0x64, 0x14, 0x34, 0xea, 0x86, 0xac, 0x55, 0x5b, - 0xca, 0xef, 0x53, 0x90, 0xf1, 0xed, 0x11, 0x5a, 0xf7, 0xe7, 0x35, 0x53, 0xbe, 0x1a, 0x85, 0xeb, - 0xed, 0x01, 0x4b, 0xba, 0xb3, 0x15, 0x4d, 0xa7, 0x42, 0xdd, 0x12, 0x26, 0x0f, 0x68, 0x03, 0xa6, - 0x74, 0xd6, 0xa1, 0x6c, 0xa3, 0x0b, 0x1c, 0x5b, 0xbe, 0x1e, 0x56, 0x3d, 0x79, 0xf4, 0x3d, 0xb8, - 0x48, 0x93, 0x68, 0xb1, 0x23, 0x58, 0x11, 0x9d, 0x3b, 0x83, 0x7c, 0xa8, 0xae, 0x0a, 0xfa, 0x11, - 0xa0, 0x48, 0x12, 0xac, 0xdc, 0x05, 0xd1, 0x59, 0x2e, 0x4e, 0xb1, 0x7a, 0x39, 0x9c, 0x30, 0x4b, - 0xf9, 0x2a, 0xe5, 0x0d, 0x15, 0x5a, 0x9e, 0xa8, 0x04, 0x73, 0xbd, 0x86, 0x85, 0xcd, 0x53, 0xdc, - 0xaa, 0x1f, 0xe3, 0x2e, 0x36, 0x35, 0x12, 0x33, 0x6d, 0x4a, 0xe4, 0xbe, 0xda, 0xf1, 0xde, 0xa0, - 0xef, 0xc0, 0x05, 0xa7, 0xa2, 0x69, 0x29, 0xcd, 0xf0, 0xd2, 0xe2, 0x73, 0x80, 0x55, 0x2a, 0xec, - 0x54, 0x1a, 0x49, 0x77, 0xdd, 0xc4, 0x47, 0x6e, 0xa5, 0x91, 0x05, 0x15, 0x1f, 0xa1, 0x87, 0xe1, - 0x84, 0xad, 0xc6, 0x27, 0x8c, 0x75, 0x97, 0x97, 0x36, 0x6d, 0x48, 0xda, 0xca, 0xa3, 0xa4, 0x8d, - 0x19, 0xe6, 0x24, 0xef, 0x0b, 0x09, 0x16, 0xf9, 0x30, 0xb8, 0xd5, 0x7c, 0x03, 0xa6, 0x59, 0x73, - 0x05, 0xae, 0x7e, 0x59, 0xba, 0xf8, 0x88, 0x5e, 0x00, 0xdf, 0x76, 0xb3, 0x39, 0x4e, 0xb2, 0x79, - 0x3b, 0x59, 0xe0, 0x6e, 0x5a, 0x95, 0x3f, 0x4a, 0xb0, 0x1c, 0x17, 0x0a, 0x17, 0xdc, 0x7d, 0xc8, - 0x45, 0x5b, 0x2d, 0x80, 0x73, 0x31, 0x9c, 0x00, 0x86, 0x78, 0x27, 0x88, 0x78, 0x7d, 0xd4, 0xdc, - 0x7a, 0xd8, 0x4d, 0xc8, 0xfa, 0x4f, 0x08, 0x2e, 0xcc, 0x1a, 0x64, 0x9b, 0xbe, 0x93, 0x83, 0x0d, - 0xea, 0x35, 0x61, 0xcd, 0x45, 0xce, 0x1a, 0x35, 0xa0, 0xaf, 0xd4, 0x60, 0x6e, 0x57, 0xb7, 0x6c, - 0x26, 0x6d, 0xa9, 0xf8, 0xe3, 0x3e, 0xb6, 0x6c, 0x67, 0xa8, 0x1f, 0x91, 0xa3, 0x91, 0xcd, 0x8d, - 0xa5, 0x98, 0x13, 0x54, 0x65, 0xe2, 0xca, 0x1e, 0xcc, 0x07, 0xed, 0x59, 0x46, 0xaf, 0x6b, 0x61, - 0x74, 0x0f, 0xa6, 0x98, 0x05, 0x67, 0x6c, 0x3b, 0x35, 0x78, 0x45, 0x68, 0x52, 0xf5, 0x44, 0x95, - 0xf7, 0x61, 0x7e, 0xcb, 0xc4, 0x9a, 0x8d, 0xdd, 0x57, 0x0c, 0xdf, 0x5d, 0xb8, 0xc8, 0x64, 0x18, - 0xc0, 0x21, 0xd6, 0x5c, 0x49, 0x65, 0x17, 0x16, 0x42, 0xc6, 0x18, 0xb8, 0x73, 0x59, 0xbb, 0x07, - 0xf3, 0xdb, 0xb8, 0x8d, 0x23, 0xd0, 0xf2, 0x00, 0x4c, 0xa4, 0xee, 0x5d, 0x4e, 0xd2, 0x6c, 0xa5, - 0xda, 0x52, 0xbe, 0x05, 0x0b, 0x21, 0x35, 0x0a, 0x42, 0xf9, 0x97, 0x04, 0x4b, 0x4f, 0x8c, 0xd6, - 0x00, 0xde, 0x66, 0xb7, 0xdb, 0xb3, 0xc9, 0x88, 0xb1, 0x92, 0xd9, 0x46, 0x2d, 0xc8, 0x68, 0x03, - 0x25, 0x76, 0xf9, 0x79, 0x18, 0x8d, 0x25, 0xc6, 0x4d, 0xd1, 0xb7, 0x44, 0x2f, 0x43, 0x7e, 0xb3, - 0xf2, 0x3b, 0x30, 0x1b, 0x16, 0x18, 0xe9, 0x22, 0xa4, 0xc0, 0xb2, 0x18, 0x00, 0x4b, 0xc6, 0xa7, - 0x90, 0xa7, 0x5b, 0x15, 0x39, 0x16, 0x92, 0x65, 0x62, 0x03, 0x26, 0xe9, 0x54, 0x61, 0x0d, 0x92, - 0xe4, 0xc0, 0x61, 0x1a, 0xca, 0x32, 0x14, 0x44, 0xbe, 0x19, 0x3a, 0x15, 0xf2, 0x74, 0x0f, 0xcf, - 0x89, 0xce, 0x6d, 0xec, 0xd4, 0xa0, 0xb1, 0x1d, 0xaf, 0x22, 0x9b, 0xcc, 0xeb, 0xef, 0x24, 0xb8, - 0x4d, 0x81, 0x0d, 0x39, 0xe2, 0x92, 0x01, 0xf8, 0x10, 0x2e, 0x47, 0x86, 0x1d, 0xcb, 0xd4, 0x68, - 0x27, 0xea, 0x6c, 0x78, 0x26, 0x2a, 0x6b, 0xb0, 0x1a, 0x0f, 0x92, 0x45, 0xf4, 0x0c, 0x6e, 0xd3, - 0x98, 0x5f, 0x3a, 0x20, 0x5e, 0x46, 0xd7, 0x60, 0x35, 0xde, 0x3a, 0x43, 0xb2, 0x0b, 0xc8, 0x19, - 0x5b, 0x34, 0xf7, 0x5e, 0xbb, 0xbd, 0x19, 0x9a, 0x82, 0x85, 0xe1, 0xdf, 0x57, 0xbc, 0x21, 0x58, - 0xa5, 0x43, 0xd5, 0xb3, 0xc6, 0xc6, 0x4c, 0x79, 0x70, 0xaa, 0xd3, 0x11, 0x98, 0x13, 0xd9, 0xf3, - 0x4e, 0x71, 0x65, 0x07, 0xe6, 0xfc, 0xc5, 0xe8, 0x22, 0xbb, 0xe3, 0xd5, 0x37, 0x45, 0x26, 0xb6, - 0xe4, 0x56, 0xf5, 0x23, 0x77, 0x92, 0xba, 0x86, 0x18, 0xa8, 0xd1, 0x2d, 0x95, 0x61, 0xce, 0x5f, - 0xa9, 0x2e, 0xa4, 0xc0, 0xd5, 0x59, 0x0a, 0x5e, 0x9d, 0x95, 0x45, 0x77, 0x58, 0x06, 0xbd, 0x2b, - 0x3f, 0x86, 0x6b, 0x4e, 0xa6, 0xc2, 0x3b, 0xe4, 0xed, 0xc0, 0xbb, 0xa1, 0x1d, 0x58, 0x4d, 0xfa, - 0x25, 0xc1, 0xdb, 0x0b, 0x13, 0xf2, 0x02, 0x0f, 0x2c, 0x01, 0x1f, 0x70, 0xef, 0x49, 0x92, 0xe8, - 0x9e, 0x1a, 0x36, 0xc4, 0xbb, 0x17, 0x19, 0xee, 0xf4, 0x8a, 0x08, 0xb3, 0xb0, 0xf6, 0x79, 0xfd, - 0x27, 0x89, 0x26, 0x55, 0xc4, 0x4a, 0xb4, 0xeb, 0x3e, 0x76, 0x67, 0x56, 0xd4, 0x23, 0x0b, 0xf3, - 0xbf, 0xee, 0xf2, 0x03, 0x77, 0x08, 0x8a, 0x82, 0x14, 0x91, 0x17, 0x49, 0x48, 0x5e, 0xbc, 0x19, - 0x28, 0x8a, 0x42, 0x39, 0x72, 0xcf, 0x8e, 0xb0, 0x44, 0xf5, 0xb1, 0x75, 0x6e, 0xbf, 0xd1, 0xef, - 0x2e, 0xca, 0x0d, 0xb8, 0x3e, 0xc4, 0x0f, 0x03, 0xf3, 0x1b, 0x09, 0x56, 0xf8, 0x59, 0xf7, 0xbe, - 0xc7, 0x9c, 0x1f, 0x53, 0xf0, 0xcb, 0x4f, 0x6a, 0xd4, 0x2f, 0x3f, 0xca, 0x6b, 0xa2, 0xc3, 0xc2, - 0x87, 0xcd, 0x17, 0x07, 0x3f, 0xda, 0xff, 0x8f, 0x38, 0x62, 0xb1, 0xb1, 0x38, 0x7a, 0x70, 0x83, - 0x1f, 0xf2, 0x63, 0xf2, 0xc9, 0xeb, 0xfc, 0x31, 0x2c, 0xc2, 0x24, 0xfd, 0x6a, 0xe6, 0x7e, 0x2d, - 0xa0, 0x4f, 0xca, 0x0a, 0xdc, 0x1c, 0xee, 0x70, 0x00, 0x8c, 0x5f, 0xd7, 0xff, 0x43, 0x60, 0xc3, - 0x1d, 0x32, 0x60, 0x1f, 0xc1, 0x0a, 0x5f, 0xee, 0xe5, 0x37, 0xde, 0xd9, 0xb8, 0x58, 0xdb, 0x0c, - 0xc6, 0x55, 0xb8, 0xe2, 0x23, 0x0d, 0x84, 0xb2, 0x78, 0x47, 0x80, 0x82, 0x41, 0xe6, 0xbd, 0x64, - 0x63, 0x6d, 0x07, 0x2e, 0xb9, 0xf7, 0x82, 0x26, 0x7d, 0xc5, 0x46, 0x77, 0x61, 0x38, 0x25, 0x52, - 0x67, 0x3a, 0x01, 0x83, 0x6b, 0xa7, 0xb0, 0xc0, 0x25, 0x96, 0x28, 0x0f, 0x57, 0x9e, 0xee, 0xef, - 0x3e, 0xd9, 0xab, 0xd4, 0x37, 0x0f, 0x0f, 0x37, 0xb7, 0x1e, 0xed, 0x55, 0x6a, 0x87, 0xf5, 0xc7, - 0x95, 0xda, 0x76, 0xb5, 0xb6, 0x33, 0x3b, 0x86, 0x0a, 0x20, 0x47, 0x5f, 0xd3, 0x9f, 0x95, 0xed, - 0x59, 0x89, 0xff, 0x7e, 0xbb, 0xc2, 0xde, 0xa7, 0xd6, 0x7e, 0x2b, 0xc1, 0x52, 0x0c, 0x3f, 0x44, - 0xab, 0x70, 0xb3, 0x56, 0x39, 0xfc, 0xc1, 0xbe, 0xfa, 0x7e, 0xbd, 0x5a, 0x3b, 0xac, 0xa8, 0xef, - 0x6d, 0x6e, 0x09, 0xd0, 0xbc, 0x06, 0xb7, 0x86, 0x4a, 0xfa, 0x80, 0xc5, 0x89, 0xfa, 0x30, 0xee, - 0x7b, 0xc4, 0x94, 0xe2, 0x99, 0x83, 0x4b, 0x7b, 0x9b, 0x5b, 0x8f, 0xaa, 0xb5, 0x8a, 0xcf, 0xb5, - 0x6f, 0x51, 0x7d, 0x52, 0xab, 0x39, 0x8b, 0x12, 0x5a, 0x80, 0xcb, 0xee, 0xe2, 0xc1, 0x93, 0x03, - 0x47, 0xd8, 0x31, 0x58, 0xfe, 0xf7, 0x3c, 0xcc, 0xb8, 0xfc, 0xa7, 0xdf, 0xb5, 0xf5, 0x0e, 0x46, - 0x75, 0xc8, 0xfa, 0x89, 0x23, 0xba, 0x15, 0xdd, 0x3f, 0x0e, 0x51, 0x95, 0x57, 0xe2, 0xc4, 0x58, - 0x89, 0x8d, 0xa1, 0x06, 0x4c, 0x07, 0xd8, 0x1f, 0xe2, 0xa8, 0xf2, 0xb8, 0xa6, 0x7c, 0x3b, 0x56, - 0xce, 0xef, 0x23, 0x40, 0xee, 0x78, 0x3e, 0x78, 0xa4, 0x91, 0xe7, 0x83, 0xcf, 0x12, 0xc7, 0xd0, - 0xcf, 0x25, 0xc8, 0x89, 0xf8, 0x13, 0x5a, 0x1f, 0x99, 0xec, 0xc9, 0xe5, 0x51, 0x54, 0x58, 0xd7, - 0x7d, 0x0e, 0x8b, 0x7c, 0x8a, 0x84, 0x4a, 0xa2, 0x64, 0x09, 0xa8, 0x92, 0x7c, 0x27, 0xb9, 0x82, - 0x97, 0x82, 0xcf, 0x61, 0x91, 0xcf, 0x95, 0x78, 0xee, 0x87, 0x32, 0x35, 0x9e, 0xfb, 0x18, 0x1a, - 0x36, 0x86, 0xbe, 0x94, 0x60, 0x39, 0x8e, 0xe3, 0xa0, 0x07, 0xa2, 0xb8, 0x62, 0xb9, 0x8e, 0xbc, - 0x71, 0x1e, 0xd5, 0x00, 0xba, 0x38, 0xde, 0xc3, 0x43, 0x97, 0x90, 0x89, 0xf1, 0xd0, 0x25, 0xa6, - 0x59, 0x63, 0xe8, 0x19, 0x64, 0x7c, 0xd4, 0x08, 0xdd, 0xe4, 0xb7, 0x6f, 0x90, 0x87, 0xc9, 0xb7, - 0x62, 0xa4, 0x3c, 0xeb, 0x75, 0xc8, 0xfa, 0x8b, 0x87, 0x37, 0x44, 0x38, 0x6c, 0x4a, 0x5e, 0x89, - 0x13, 0xf3, 0x3b, 0xf0, 0x97, 0x07, 0xcf, 0x01, 0x87, 0x1b, 0xc9, 0x2b, 0x71, 0x62, 0x9e, 0x83, - 0x4f, 0x60, 0x81, 0x4b, 0x57, 0x50, 0x91, 0x9f, 0x03, 0x11, 0x73, 0x92, 0x4b, 0x89, 0xe5, 0x59, - 0x4f, 0x7f, 0xe6, 0xf6, 0x74, 0xe4, 0xff, 0x04, 0x4b, 0x49, 0xeb, 0x31, 0xb6, 0xa7, 0x85, 0xec, - 0xe4, 0x33, 0xb7, 0xa3, 0x93, 0x38, 0x1f, 0x4a, 0x3b, 0xc4, 0x1d, 0x2d, 0x74, 0xfe, 0x0b, 0x09, - 0xae, 0x08, 0x6f, 0xfb, 0x48, 0x38, 0x1f, 0xc5, 0x14, 0x44, 0xbe, 0x3b, 0x92, 0x0e, 0x83, 0xf1, - 0x6b, 0x09, 0x96, 0x62, 0xae, 0xec, 0xe8, 0x7e, 0xd2, 0xcc, 0x86, 0x2f, 0x70, 0xf2, 0x83, 0x73, - 0x68, 0xfa, 0x80, 0xc5, 0xdc, 0xc1, 0x79, 0xc0, 0x92, 0x51, 0x0a, 0x1e, 0xb0, 0x84, 0x17, 0x7e, - 0x02, 0x2c, 0xe6, 0x8e, 0xc9, 0x03, 0x96, 0xec, 0xca, 0x2b, 0x3f, 0x38, 0x87, 0x26, 0x03, 0xf6, - 0x2b, 0x09, 0xae, 0x0d, 0x63, 0x06, 0xe8, 0x5e, 0xd2, 0xdd, 0x08, 0x30, 0x04, 0xf9, 0xcd, 0x51, - 0xd5, 0x7c, 0x78, 0x86, 0x11, 0x02, 0x1e, 0x9e, 0x04, 0x8c, 0x85, 0x87, 0x27, 0x09, 0xef, 0x40, - 0x3d, 0xfa, 0xb9, 0x2d, 0x78, 0xa7, 0x47, 0xdf, 0x1e, 0x7a, 0x97, 0x0b, 0xd2, 0x02, 0xf9, 0xf5, - 0x64, 0xc2, 0xd4, 0xe1, 0xc3, 0xa7, 0x5f, 0x7f, 0x53, 0x90, 0xfe, 0xfe, 0x4d, 0x61, 0xec, 0x67, - 0x2f, 0x0a, 0xd2, 0xd7, 0x2f, 0x0a, 0xd2, 0x5f, 0x5f, 0x14, 0xa4, 0x7f, 0xbc, 0x28, 0x48, 0x5f, - 0xfc, 0xb3, 0x30, 0xf6, 0xd1, 0xfd, 0xc4, 0x7f, 0xb1, 0x45, 0xad, 0x7b, 0x7f, 0xb4, 0xd5, 0x98, - 0x24, 0x7f, 0xb1, 0x75, 0xf7, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x34, 0xdc, 0x82, 0x40, - 0x26, 0x00, 0x00, + // 2372 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4d, 0x73, 0xdb, 0xc6, + 0xf9, 0x17, 0xa8, 0x57, 0x3e, 0xa4, 0x64, 0x7a, 0xf5, 0xf2, 0xa7, 0x61, 0x8b, 0x92, 0x61, 0x5b, + 0x56, 0xf4, 0x77, 0x48, 0x8b, 0xae, 0x1d, 0xdb, 0x6d, 0xd2, 0xc8, 0x12, 0x63, 0x73, 0x22, 0xd1, + 0x0a, 0x24, 0xbb, 0x4d, 0xea, 0x19, 0x16, 0x24, 0x57, 0x32, 0x6a, 0x90, 0x40, 0x00, 0x50, 0xb5, + 0x92, 0xc9, 0x4c, 0x3b, 0xd3, 0x4b, 0x0f, 0x9d, 0xc9, 0xa9, 0x87, 0xfa, 0xd4, 0xe9, 0xb9, 0x33, + 0xbd, 0x36, 0xd3, 0x0f, 0x90, 0x53, 0xa7, 0xb7, 0xf6, 0xd8, 0xb8, 0x33, 0x3d, 0xf6, 0x33, 0x74, + 0xb0, 0xbb, 0x00, 0xf1, 0xb2, 0x20, 0x40, 0xb9, 0xcd, 0xf4, 0x24, 0xec, 0xe2, 0x79, 0xf9, 0x3d, + 0xaf, 0xbb, 0x0f, 0x44, 0xc8, 0x2a, 0x86, 0x5a, 0x36, 0x4c, 0xdd, 0xd6, 0x51, 0xa1, 0xab, 0xb4, + 0x9f, 0xab, 0x3d, 0x5c, 0x3e, 0xd9, 0x54, 0x34, 0xe3, 0xb9, 0xb2, 0x29, 0xbe, 0x7d, 0xac, 0xda, + 0xcf, 0xfb, 0xad, 0x72, 0x5b, 0xef, 0x56, 0x8e, 0xf5, 0x63, 0xbd, 0x42, 0x08, 0x5b, 0xfd, 0x23, + 0xb2, 0x22, 0x0b, 0xf2, 0x44, 0x05, 0x88, 0xdf, 0xf7, 0x91, 0xeb, 0xbd, 0x2e, 0xb6, 0x15, 0xcd, + 0xfd, 0xfb, 0xb6, 0x62, 0xa8, 0x15, 0xdd, 0x54, 0x2b, 0x8a, 0xa1, 0x5a, 0x15, 0x67, 0xab, 0xe2, + 0x6a, 0xa9, 0x78, 0x08, 0xa4, 0xaf, 0x04, 0xc8, 0x3f, 0xd5, 0xb5, 0x7e, 0x17, 0x7f, 0xa0, 0x6a, + 0x36, 0x36, 0xd1, 0x1c, 0x64, 0xd4, 0x4e, 0x51, 0x58, 0x15, 0xd6, 0xb3, 0x72, 0x46, 0xed, 0xa0, + 0x1f, 0xc2, 0x9c, 0xa6, 0xb4, 0xb0, 0xd6, 0xb4, 0xb0, 0x86, 0xdb, 0xb6, 0x6e, 0x16, 0x33, 0xab, + 0xe3, 0xeb, 0xb9, 0xea, 0x66, 0x39, 0x8c, 0xbd, 0xec, 0x97, 0x53, 0xde, 0x75, 0x98, 0x0e, 0x18, + 0x4f, 0xad, 0x67, 0x9b, 0xa7, 0xf2, 0xac, 0xe6, 0xdf, 0x13, 0xdf, 0x07, 0x14, 0x25, 0x42, 0x05, + 0x18, 0x7f, 0x81, 0x4f, 0x19, 0x00, 0xe7, 0x11, 0x2d, 0xc0, 0xe4, 0x89, 0xa2, 0xf5, 0x71, 0x31, + 0x43, 0xf6, 0xe8, 0xe2, 0x7e, 0xe6, 0xae, 0x20, 0xfd, 0x35, 0x03, 0x40, 0x95, 0x1e, 0x18, 0xb8, + 0x8d, 0x96, 0x60, 0xaa, 0x63, 0xaa, 0x27, 0xd8, 0x64, 0xdc, 0x6c, 0xe5, 0xec, 0x3f, 0x57, 0x7a, + 0x1d, 0xcd, 0x95, 0xc0, 0x56, 0x68, 0x17, 0x40, 0xb1, 0x6d, 0x53, 0x6d, 0xf5, 0x6d, 0x6c, 0x15, + 0xc7, 0x89, 0x59, 0x37, 0xe2, 0xcc, 0x72, 0x34, 0x94, 0xb7, 0x3c, 0x72, 0x6a, 0x91, 0x8f, 0x1f, + 0xed, 0x41, 0xce, 0xc2, 0x6d, 0x13, 0xdb, 0xcd, 0x8e, 0x62, 0x2b, 0xc5, 0x89, 0x14, 0xe2, 0x0e, + 0x08, 0xfd, 0x8e, 0x62, 0x2b, 0x4c, 0x9c, 0xe5, 0x6d, 0x88, 0xef, 0xc2, 0xb9, 0x90, 0xb6, 0x51, + 0x5c, 0xe3, 0xb0, 0x87, 0xa4, 0x27, 0xb1, 0xe7, 0xfd, 0x9e, 0xed, 0xc3, 0x14, 0xc5, 0x89, 0xee, + 0xc1, 0x8c, 0x93, 0x3b, 0xc4, 0x26, 0x87, 0x35, 0x57, 0x5d, 0x2e, 0x3b, 0x1b, 0x03, 0x83, 0x1e, + 0xb7, 0x7e, 0x82, 0xdb, 0xf6, 0x1e, 0x23, 0x92, 0x3d, 0x72, 0x74, 0x13, 0x26, 0x2c, 0x03, 0xb7, + 0x89, 0xf4, 0x5c, 0xf5, 0xd2, 0x30, 0x57, 0xc8, 0x84, 0x52, 0xfa, 0xb3, 0x00, 0x4b, 0x0d, 0x6c, + 0xff, 0x54, 0x37, 0x5f, 0xd4, 0x7b, 0x36, 0x36, 0x8f, 0x94, 0x76, 0x5c, 0x5e, 0xb6, 0x62, 0xf2, + 0xf2, 0xbb, 0x51, 0x35, 0x7c, 0x89, 0xdf, 0x4a, 0x86, 0x5e, 0x83, 0x1c, 0xd3, 0xee, 0x66, 0x28, + 0xcb, 0x44, 0xc1, 0x9f, 0x89, 0xd2, 0x0a, 0xcc, 0x3e, 0x55, 0x4d, 0xbb, 0xaf, 0x68, 0xf5, 0x7d, + 0x42, 0xe8, 0x58, 0x6b, 0x78, 0xd6, 0x1a, 0xd2, 0x4b, 0x28, 0xec, 0xea, 0x4a, 0xe7, 0x81, 0xa2, + 0x29, 0xbd, 0x36, 0x36, 0xf7, 0x75, 0xd3, 0x46, 0x77, 0x60, 0x86, 0xd4, 0x70, 0x5b, 0xd7, 0x08, + 0xe5, 0x5c, 0x55, 0x8c, 0xda, 0xbe, 0xcf, 0x28, 0x64, 0x8f, 0x16, 0x21, 0x98, 0x30, 0x74, 0xd3, + 0x26, 0x60, 0x27, 0x65, 0xf2, 0x8c, 0x8a, 0x30, 0x8d, 0x7b, 0x1d, 0x47, 0x6c, 0x71, 0x9c, 0x6c, + 0xbb, 0x4b, 0xa9, 0x05, 0x4b, 0x7e, 0xcd, 0x87, 0x8a, 0x79, 0x8c, 0x6d, 0x1e, 0x46, 0x74, 0x17, + 0x26, 0x1d, 0x59, 0x16, 0x0b, 0x84, 0x14, 0x05, 0x13, 0x36, 0x41, 0xa6, 0x0c, 0xd2, 0xab, 0x0c, + 0x2c, 0x84, 0x83, 0x44, 0x54, 0xbc, 0x03, 0xd3, 0x3d, 0xba, 0x3f, 0xc8, 0xbd, 0x98, 0xe8, 0x92, + 0x2c, 0x72, 0xa9, 0x9d, 0x18, 0xa9, 0x06, 0x45, 0x92, 0x95, 0x9d, 0x47, 0xf4, 0x1e, 0xc0, 0x09, + 0x75, 0x71, 0x53, 0x35, 0x88, 0x91, 0xb9, 0xea, 0x0a, 0x27, 0x25, 0xfd, 0x61, 0x90, 0xb3, 0x8c, + 0xa5, 0x6e, 0x20, 0xd1, 0xf1, 0x36, 0x3e, 0x52, 0x5f, 0x62, 0x8b, 0xd4, 0x76, 0x56, 0xf6, 0xd6, + 0xe8, 0x19, 0x2c, 0x6a, 0xba, 0xd2, 0x69, 0xb6, 0x98, 0x6d, 0x4d, 0x9b, 0x78, 0xc9, 0x2a, 0x4e, + 0x12, 0x4f, 0xac, 0x0f, 0xf7, 0xc4, 0xc0, 0xa5, 0xf2, 0xbc, 0x16, 0xd9, 0xb7, 0xa4, 0x5f, 0x0a, + 0x50, 0x08, 0x7b, 0xe7, 0x4d, 0xca, 0xf2, 0x7e, 0xa0, 0x2c, 0xd7, 0x92, 0xeb, 0xc5, 0x57, 0xa0, + 0x12, 0xe4, 0xeb, 0xc7, 0x3d, 0xd5, 0x56, 0xf5, 0x1e, 0x09, 0x10, 0x82, 0x09, 0x0f, 0x42, 0x5e, + 0x26, 0xcf, 0xd2, 0x9f, 0x04, 0x98, 0xdd, 0xa3, 0x32, 0x63, 0x6a, 0xf7, 0xe3, 0x98, 0xda, 0xad, + 0x46, 0xb1, 0x04, 0x04, 0x7d, 0x2b, 0x25, 0xfb, 0x0c, 0x8a, 0x4c, 0xe9, 0xb6, 0xa6, 0x58, 0xd6, + 0xb6, 0x62, 0x28, 0x2d, 0x55, 0x53, 0x6d, 0x15, 0x5b, 0x68, 0x19, 0xa0, 0x6d, 0xf4, 0x9b, 0x5d, + 0x55, 0xd3, 0x54, 0x8b, 0x88, 0x1b, 0x97, 0xb3, 0x6d, 0xa3, 0xbf, 0x47, 0x36, 0xd0, 0x65, 0xc8, + 0x77, 0x71, 0x57, 0x37, 0x4f, 0x9b, 0xad, 0x53, 0xe7, 0x48, 0x71, 0x64, 0x4f, 0xc8, 0x39, 0xba, + 0xf7, 0xc0, 0xd9, 0x92, 0xfe, 0x20, 0xc0, 0x34, 0x13, 0xff, 0x26, 0x31, 0xdc, 0x0c, 0xc4, 0x70, + 0x39, 0xd6, 0x6f, 0x83, 0xd0, 0xa1, 0x77, 0x60, 0xca, 0xb2, 0x15, 0xbb, 0x6f, 0xc5, 0x27, 0xbf, + 0xcb, 0x44, 0xc8, 0x64, 0x46, 0x2e, 0x5d, 0x86, 0x6c, 0xbd, 0xab, 0x1c, 0xd3, 0x8a, 0x5c, 0x80, + 0x49, 0xd5, 0x59, 0x30, 0x5f, 0xd2, 0x85, 0x54, 0x86, 0xd9, 0x5a, 0xd7, 0xb0, 0x4f, 0x77, 0x54, + 0x8b, 0x36, 0xba, 0x65, 0x00, 0x4b, 0xfd, 0x0c, 0x33, 0x3f, 0x08, 0xc4, 0x0f, 0x59, 0x67, 0x87, + 0x7a, 0xe1, 0x95, 0x00, 0x05, 0xda, 0xfc, 0xb7, 0x6c, 0x5b, 0x69, 0x3f, 0xef, 0xe2, 0x9e, 0xed, + 0xe4, 0x52, 0x4f, 0xe9, 0xba, 0x92, 0xc9, 0x33, 0x39, 0xd2, 0xf1, 0x89, 0xda, 0xf6, 0x8e, 0x6e, + 0xba, 0x42, 0x17, 0x21, 0x7b, 0x42, 0xf8, 0x9b, 0x6a, 0x87, 0xd8, 0x93, 0x95, 0x67, 0xe8, 0x46, + 0xbd, 0xe3, 0x94, 0x3a, 0x76, 0xd0, 0x34, 0x3b, 0xaa, 0xf5, 0xa2, 0x38, 0x11, 0x67, 0x6d, 0x00, + 0xb1, 0x9c, 0xc5, 0xee, 0x52, 0x6a, 0x81, 0x18, 0x2e, 0x81, 0x04, 0x98, 0x37, 0x61, 0x81, 0x75, + 0x9e, 0xa6, 0xea, 0xb2, 0x38, 0xc8, 0x28, 0x68, 0xd4, 0x0b, 0x49, 0xab, 0x77, 0xa4, 0xdf, 0x67, + 0x20, 0xe7, 0x8b, 0x11, 0xda, 0xf4, 0xfb, 0x35, 0x57, 0xbd, 0x18, 0x85, 0xeb, 0xc5, 0x80, 0x39, + 0xdd, 0x09, 0x45, 0xdb, 0xc9, 0x50, 0x37, 0x85, 0xc9, 0x02, 0xdd, 0x87, 0x19, 0x95, 0x55, 0x28, + 0x0b, 0x74, 0x89, 0x23, 0xcb, 0x57, 0xc3, 0xb2, 0x47, 0x8f, 0xbe, 0x07, 0xd3, 0xd4, 0x89, 0x16, + 0xbb, 0xbe, 0x48, 0x71, 0x67, 0xf6, 0xc0, 0x1f, 0xb2, 0xcb, 0x82, 0x7e, 0x04, 0x28, 0xe2, 0x04, + 0xb7, 0x05, 0xde, 0x48, 0xee, 0x32, 0x3e, 0x91, 0xe7, 0xc3, 0x0e, 0xb3, 0xa4, 0xaf, 0x32, 0x5e, + 0x53, 0xa1, 0xe9, 0x89, 0x2a, 0x30, 0xaf, 0xb7, 0x2c, 0x6c, 0x9e, 0xe0, 0x4e, 0xf3, 0x18, 0xf7, + 0xb0, 0xa9, 0x10, 0x9b, 0x69, 0x51, 0x22, 0xf7, 0xd5, 0x43, 0xef, 0x0d, 0xfa, 0x0e, 0x4c, 0x3a, + 0x19, 0x4d, 0x53, 0x69, 0x8e, 0xe7, 0x16, 0x9f, 0x02, 0x2c, 0x53, 0x62, 0x27, 0xd3, 0x88, 0xbb, + 0x9b, 0x26, 0x3e, 0x72, 0x33, 0x8d, 0x6c, 0xc8, 0xf8, 0x08, 0x3d, 0x08, 0x3b, 0x6c, 0x3d, 0xd9, + 0x61, 0xac, 0xba, 0x3c, 0xb7, 0x29, 0x43, 0xdc, 0x56, 0x1d, 0xc5, 0x6d, 0x4c, 0x30, 0xc7, 0x79, + 0x5f, 0x0a, 0xb0, 0xc4, 0x87, 0xc1, 0xcd, 0xe6, 0x2b, 0x30, 0xcb, 0x8a, 0x2b, 0x70, 0x6d, 0xce, + 0xd3, 0xcd, 0x47, 0xf4, 0xf2, 0xfc, 0xae, 0xeb, 0xcd, 0x71, 0xe2, 0xcd, 0xeb, 0xe9, 0x0c, 0x77, + 0xdd, 0x2a, 0xfd, 0x51, 0x80, 0xd5, 0x24, 0x53, 0xb8, 0xe0, 0xee, 0x42, 0x31, 0x5a, 0x6a, 0x01, + 0x9c, 0x4b, 0x61, 0x07, 0x30, 0xc4, 0x0f, 0x83, 0x88, 0x37, 0x47, 0xf5, 0xad, 0x87, 0xdd, 0x84, + 0xbc, 0xff, 0x84, 0xe0, 0xc2, 0x6c, 0x40, 0xbe, 0xed, 0x3b, 0x39, 0x58, 0xa3, 0xde, 0x88, 0xcd, + 0xb9, 0xc8, 0x59, 0x23, 0x07, 0xf8, 0xa5, 0x06, 0xcc, 0xef, 0xaa, 0x96, 0xcd, 0xa8, 0x2d, 0x19, + 0x7f, 0xda, 0xc7, 0x96, 0xed, 0x34, 0xf5, 0x23, 0x72, 0x34, 0xb2, 0xbe, 0xb1, 0x92, 0x70, 0x82, + 0xca, 0x8c, 0x5c, 0xda, 0x83, 0x85, 0xa0, 0x3c, 0xcb, 0xd0, 0x7b, 0x16, 0x46, 0xb7, 0x61, 0x86, + 0x49, 0x70, 0xda, 0xb6, 0x93, 0x83, 0x17, 0x62, 0x45, 0xca, 0x1e, 0xa9, 0xf4, 0x21, 0x2c, 0x6c, + 0x9b, 0x58, 0xb1, 0xb1, 0xfb, 0x8a, 0xe1, 0xbb, 0x05, 0xd3, 0x8c, 0x86, 0x01, 0x1c, 0x22, 0xcd, + 0xa5, 0x94, 0x76, 0x61, 0x31, 0x24, 0x8c, 0x81, 0x3b, 0x93, 0xb4, 0xdb, 0xb0, 0xb0, 0x83, 0x35, + 0x1c, 0x81, 0xb6, 0x0c, 0xc0, 0x48, 0x9a, 0xde, 0xe5, 0x24, 0xcb, 0x76, 0xea, 0x1d, 0xe9, 0xff, + 0x60, 0x31, 0xc4, 0x46, 0x41, 0x48, 0xff, 0x14, 0x60, 0xe5, 0x89, 0xd1, 0x19, 0xc0, 0xdb, 0xea, + 0xf5, 0x74, 0x9b, 0xb4, 0x18, 0x2b, 0x9d, 0x6c, 0xd4, 0x81, 0x9c, 0x32, 0x60, 0x62, 0x97, 0x9f, + 0x07, 0x51, 0x5b, 0x12, 0xd4, 0x94, 0x7d, 0x5b, 0xf4, 0x32, 0xe4, 0x17, 0x2b, 0xbe, 0x07, 0x85, + 0x30, 0xc1, 0x48, 0x17, 0x21, 0x09, 0x56, 0xe3, 0x01, 0x30, 0x67, 0x7c, 0x06, 0xcb, 0x34, 0x54, + 0x91, 0x63, 0x21, 0x9d, 0x27, 0xee, 0xc3, 0x14, 0xed, 0x2a, 0xac, 0x40, 0xd2, 0x1c, 0x38, 0x8c, + 0x43, 0x5a, 0x85, 0x52, 0x9c, 0x6e, 0x86, 0x4e, 0x86, 0x65, 0x1a, 0xc3, 0x33, 0xa2, 0x73, 0x0b, + 0x3b, 0x33, 0x28, 0x6c, 0x47, 0x6b, 0x9c, 0x4c, 0xa6, 0xf5, 0x77, 0x02, 0x5c, 0xa7, 0xc0, 0x86, + 0x1c, 0x71, 0xe9, 0x00, 0x7c, 0x0c, 0xe7, 0x23, 0xcd, 0x8e, 0x79, 0x6a, 0xb4, 0x13, 0xb5, 0x10, + 0xee, 0x89, 0xd2, 0x06, 0xac, 0x27, 0x83, 0x64, 0x16, 0x3d, 0x83, 0xeb, 0xd4, 0xe6, 0x37, 0x36, + 0x88, 0xe7, 0xd1, 0x0d, 0x58, 0x4f, 0x96, 0xce, 0x90, 0xec, 0x02, 0x72, 0xda, 0x16, 0xf5, 0xbd, + 0x57, 0x6e, 0x77, 0x42, 0x5d, 0xb0, 0x34, 0xfc, 0xdb, 0x94, 0xd7, 0x04, 0xeb, 0xb4, 0xa9, 0x7a, + 0xd2, 0x58, 0x9b, 0xa9, 0x0e, 0x4e, 0x75, 0xda, 0x02, 0x8b, 0x71, 0xf2, 0xbc, 0x53, 0x5c, 0x7a, + 0x08, 0xf3, 0xfe, 0x64, 0x74, 0x91, 0xdd, 0xf4, 0xf2, 0x9b, 0x22, 0x8b, 0x97, 0xe4, 0x66, 0xf5, + 0x23, 0xb7, 0x93, 0xba, 0x82, 0x18, 0xa8, 0xd1, 0x25, 0x55, 0x61, 0xde, 0x9f, 0xa9, 0x2e, 0xa4, + 0xc0, 0xd5, 0x59, 0x08, 0x5e, 0x9d, 0xa5, 0x25, 0xb7, 0x59, 0x06, 0xb5, 0x4b, 0x3f, 0x86, 0x4b, + 0x8e, 0xa7, 0xc2, 0x11, 0xf2, 0x22, 0xf0, 0x7e, 0x28, 0x02, 0xeb, 0x69, 0xbf, 0xc2, 0x78, 0xb1, + 0x30, 0x61, 0x39, 0x46, 0x03, 0x73, 0xc0, 0x47, 0xdc, 0x7b, 0x92, 0x10, 0x77, 0x4f, 0x0d, 0x0b, + 0xe2, 0xdd, 0x8b, 0x0c, 0xb7, 0x7b, 0x45, 0x88, 0x99, 0x59, 0x8f, 0x79, 0xf5, 0x27, 0xc4, 0x75, + 0xaa, 0x88, 0x94, 0x68, 0xd5, 0x7d, 0xea, 0xf6, 0xac, 0xa8, 0x46, 0x66, 0xe6, 0x7f, 0x5c, 0xe5, + 0x47, 0x6e, 0x13, 0x8c, 0x33, 0x32, 0x6e, 0x78, 0x11, 0x62, 0x87, 0x17, 0xaf, 0x07, 0xc6, 0x59, + 0x21, 0x1d, 0xb9, 0x67, 0x47, 0x98, 0xa2, 0xbe, 0x6f, 0x9d, 0x59, 0x6f, 0xf4, 0xab, 0x8e, 0x74, + 0x05, 0x2e, 0x0f, 0xd1, 0xc3, 0xc0, 0xfc, 0x46, 0x80, 0x35, 0xbe, 0xd7, 0xbd, 0xaf, 0x3d, 0x67, + 0xc7, 0x14, 0xfc, 0xae, 0x94, 0x19, 0xf5, 0xbb, 0x92, 0xf4, 0x56, 0xdc, 0x61, 0xe1, 0xc3, 0xe6, + 0xb3, 0x83, 0x6f, 0xed, 0xff, 0x86, 0x1d, 0x89, 0xd8, 0x98, 0x1d, 0x3a, 0x5c, 0xe1, 0x9b, 0xbc, + 0x4f, 0x3e, 0xa8, 0x9d, 0xdd, 0x86, 0x25, 0x98, 0xa2, 0xdf, 0xe4, 0xdc, 0xaf, 0x05, 0x74, 0x25, + 0xad, 0xc1, 0xd5, 0xe1, 0x0a, 0x07, 0xc0, 0xf8, 0x79, 0xfd, 0x5f, 0x04, 0x36, 0x5c, 0x21, 0x03, + 0xf6, 0x09, 0xac, 0xf1, 0xe9, 0xde, 0x3c, 0xf0, 0x4e, 0xe0, 0x12, 0x65, 0x33, 0x18, 0x17, 0xe1, + 0x82, 0x6f, 0x68, 0x20, 0x23, 0x8b, 0x77, 0x04, 0x48, 0x18, 0x44, 0xde, 0x4b, 0xd6, 0xd6, 0x1e, + 0xc2, 0x39, 0xf7, 0x5e, 0xd0, 0xa6, 0xaf, 0x58, 0xeb, 0x2e, 0x0d, 0x1f, 0x89, 0xe4, 0xb9, 0x6e, + 0x40, 0xe0, 0xc6, 0x1a, 0xcc, 0xb8, 0xdf, 0xb4, 0xd1, 0x34, 0x8c, 0x1f, 0x6e, 0xef, 0x17, 0xc6, + 0x9c, 0x87, 0x27, 0x3b, 0xfb, 0x05, 0x01, 0xcd, 0xc0, 0xc4, 0xc1, 0xf6, 0xe1, 0x7e, 0x21, 0xb3, + 0x71, 0x02, 0x8b, 0xdc, 0x01, 0x14, 0x2d, 0xc3, 0x85, 0xa7, 0x8f, 0x77, 0x9f, 0xec, 0xd5, 0x9a, + 0x5b, 0x87, 0x87, 0x5b, 0xdb, 0x8f, 0xf6, 0x6a, 0x8d, 0xc3, 0xe6, 0x7e, 0xad, 0xb1, 0x53, 0x6f, + 0x3c, 0x2c, 0x8c, 0xa1, 0x12, 0x88, 0xd1, 0xd7, 0xf4, 0xb1, 0xb6, 0x53, 0x10, 0xf8, 0xef, 0x77, + 0x6a, 0xec, 0x7d, 0x66, 0xe3, 0xb7, 0x02, 0xac, 0x24, 0xcc, 0x91, 0x68, 0x1d, 0xae, 0x36, 0x6a, + 0x87, 0x3f, 0x78, 0x2c, 0x7f, 0xd8, 0xac, 0x37, 0x0e, 0x6b, 0xf2, 0x07, 0x5b, 0xdb, 0x31, 0x68, + 0xde, 0x82, 0x6b, 0x43, 0x29, 0x7d, 0xc0, 0x92, 0x48, 0x7d, 0x18, 0x1f, 0x7b, 0x03, 0x2c, 0xc5, + 0x33, 0x0f, 0xe7, 0xf6, 0xb6, 0xb6, 0x1f, 0xd5, 0x1b, 0x35, 0x9f, 0x6a, 0xdf, 0xa6, 0xfc, 0xa4, + 0xd1, 0x70, 0x36, 0x05, 0xb4, 0x08, 0xe7, 0xdd, 0xcd, 0x83, 0x27, 0x07, 0x0e, 0xb1, 0x23, 0xb0, + 0xfa, 0xaf, 0x05, 0x98, 0x73, 0xe7, 0xa4, 0x7e, 0xcf, 0x56, 0xbb, 0x18, 0x35, 0x21, 0xef, 0x1f, + 0x30, 0xd1, 0x35, 0xce, 0x47, 0xf0, 0xe8, 0x40, 0x2b, 0xae, 0x25, 0x91, 0xb1, 0x54, 0x1c, 0x43, + 0x2d, 0x98, 0x0d, 0x4c, 0x89, 0x88, 0xc3, 0xca, 0x9b, 0x49, 0xc5, 0xeb, 0x89, 0x74, 0x7e, 0x1d, + 0x81, 0x21, 0x90, 0xa7, 0x83, 0x37, 0x5c, 0xf2, 0x74, 0xf0, 0xa7, 0xc9, 0x31, 0xf4, 0x73, 0x01, + 0x8a, 0x71, 0x73, 0x16, 0xda, 0x1c, 0x79, 0x28, 0x14, 0xab, 0xa3, 0xb0, 0xb0, 0xea, 0xfc, 0x02, + 0x96, 0xf8, 0xa3, 0x14, 0xaa, 0xc4, 0x39, 0x2b, 0x66, 0xa4, 0x12, 0x6f, 0xa6, 0x67, 0xf0, 0x5c, + 0xf0, 0x05, 0x2c, 0xf1, 0x67, 0x2a, 0x9e, 0xfa, 0xa1, 0x13, 0x1d, 0x4f, 0x7d, 0xc2, 0xb8, 0x36, + 0x86, 0x5e, 0x09, 0xb0, 0x9a, 0x34, 0x0b, 0xa1, 0x7b, 0x71, 0x76, 0x25, 0xce, 0x44, 0xe2, 0xfd, + 0xb3, 0xb0, 0x06, 0xd0, 0x25, 0xcd, 0x47, 0x3c, 0x74, 0x29, 0x27, 0x36, 0x1e, 0xba, 0xd4, 0xe3, + 0xd8, 0x18, 0x7a, 0x06, 0x39, 0xdf, 0x08, 0x85, 0xae, 0xf2, 0xcb, 0x37, 0x38, 0xaf, 0x89, 0xd7, + 0x12, 0xa8, 0x3c, 0xe9, 0x4d, 0xc8, 0xfb, 0x93, 0x87, 0xd7, 0x44, 0x38, 0x53, 0x97, 0xb8, 0x96, + 0x44, 0xe6, 0x57, 0xe0, 0x4f, 0x0f, 0x9e, 0x02, 0xce, 0x0c, 0x25, 0xae, 0x25, 0x91, 0x79, 0x0a, + 0x5e, 0xc2, 0x22, 0x77, 0xac, 0x41, 0x65, 0xbe, 0x0f, 0xe2, 0x26, 0x2c, 0xb1, 0x92, 0x9a, 0x9e, + 0xd5, 0xf4, 0xe7, 0x6e, 0x4d, 0x47, 0xfe, 0x77, 0x58, 0x49, 0x9b, 0x8f, 0x89, 0x35, 0x1d, 0x3b, + 0xc5, 0x7c, 0xee, 0x56, 0x74, 0x1a, 0xe5, 0x43, 0xc7, 0x93, 0xf8, 0x8a, 0x8e, 0x55, 0xfe, 0x0b, + 0x01, 0x2e, 0xc4, 0x4e, 0x05, 0x28, 0xb6, 0x3f, 0xc6, 0x8f, 0x2a, 0xe2, 0xad, 0x91, 0x78, 0x18, + 0x8c, 0x5f, 0x0b, 0xb0, 0x92, 0x70, 0xb5, 0x47, 0x77, 0xd3, 0x7a, 0x36, 0x7c, 0xd1, 0x13, 0xef, + 0x9d, 0x81, 0xd3, 0x07, 0x2c, 0xe1, 0xae, 0xce, 0x03, 0x96, 0x6e, 0xf4, 0xe0, 0x01, 0x4b, 0x39, + 0x18, 0x10, 0x60, 0x09, 0x77, 0x51, 0x1e, 0xb0, 0x74, 0x57, 0x63, 0xf1, 0xde, 0x19, 0x38, 0x19, + 0xb0, 0x5f, 0x09, 0x70, 0x69, 0xd8, 0x04, 0x81, 0x6e, 0xa7, 0x8d, 0x46, 0x60, 0x92, 0x10, 0xef, + 0x8c, 0xca, 0xe6, 0xc3, 0x33, 0x6c, 0x70, 0xe0, 0xe1, 0x49, 0x31, 0xd9, 0xf0, 0xf0, 0xa4, 0x99, + 0x4f, 0x90, 0x4e, 0x3f, 0xcb, 0x05, 0xef, 0xfe, 0xe8, 0xff, 0x87, 0xde, 0xe5, 0x82, 0xe3, 0x83, + 0x78, 0x23, 0x1d, 0x31, 0x55, 0xf8, 0xe0, 0xe9, 0xd7, 0xdf, 0x94, 0x84, 0xbf, 0x7d, 0x53, 0x1a, + 0xfb, 0xd9, 0xeb, 0x92, 0xf0, 0xf5, 0xeb, 0x92, 0xf0, 0x97, 0xd7, 0x25, 0xe1, 0xef, 0xaf, 0x4b, + 0xc2, 0x97, 0xff, 0x28, 0x8d, 0x7d, 0x72, 0x37, 0xf5, 0xaf, 0xe2, 0xa8, 0x74, 0xef, 0x87, 0x71, + 0xad, 0x29, 0xf2, 0x2b, 0x99, 0x5b, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xac, 0x56, 0x7f, 0x77, + 0xa4, 0x27, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -4481,7 +4643,7 @@ func (m *VirtualIPSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *NetworkInterfaceSpec) Marshal() (dAtA []byte, err error) { +func (m *LoadBalancerPort) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4491,57 +4653,153 @@ func (m *NetworkInterfaceSpec) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *NetworkInterfaceSpec) MarshalTo(dAtA []byte) (int, error) { +func (m *LoadBalancerPort) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *NetworkInterfaceSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *LoadBalancerPort) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Prefixes) > 0 { - for iNdEx := len(m.Prefixes) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Prefixes[iNdEx]) - copy(dAtA[i:], m.Prefixes[iNdEx]) - i = encodeVarintApi(dAtA, i, uint64(len(m.Prefixes[iNdEx]))) - i-- - dAtA[i] = 0x22 - } - } - if m.VirtualIp != nil { - { - size, err := m.VirtualIp.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintApi(dAtA, i, uint64(size)) - } + if m.EndPort != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.EndPort)) i-- - dAtA[i] = 0x1a - } - if len(m.Ips) > 0 { - for iNdEx := len(m.Ips) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Ips[iNdEx]) - copy(dAtA[i:], m.Ips[iNdEx]) - i = encodeVarintApi(dAtA, i, uint64(len(m.Ips[iNdEx]))) - i-- - dAtA[i] = 0x12 - } + dAtA[i] = 0x18 } - if m.Network != nil { - { - size, err := m.Network.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintApi(dAtA, i, uint64(size)) - } + if m.Port != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Port)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x10 + } + if m.Protocol != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Protocol)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LoadBalancerTargetSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LoadBalancerTargetSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LoadBalancerTargetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ports) > 0 { + for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Ip) > 0 { + i -= len(m.Ip) + copy(dAtA[i:], m.Ip) + i = encodeVarintApi(dAtA, i, uint64(len(m.Ip))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NetworkInterfaceSpec) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *NetworkInterfaceSpec) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NetworkInterfaceSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.LoadBalancerTargets) > 0 { + for iNdEx := len(m.LoadBalancerTargets) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.LoadBalancerTargets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.Prefixes) > 0 { + for iNdEx := len(m.Prefixes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Prefixes[iNdEx]) + copy(dAtA[i:], m.Prefixes[iNdEx]) + i = encodeVarintApi(dAtA, i, uint64(len(m.Prefixes[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if m.VirtualIp != nil { + { + size, err := m.VirtualIp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Ips) > 0 { + for iNdEx := len(m.Ips) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Ips[iNdEx]) + copy(dAtA[i:], m.Ips[iNdEx]) + i = encodeVarintApi(dAtA, i, uint64(len(m.Ips[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if m.Network != nil { + { + size, err := m.Network.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } @@ -6656,6 +6914,43 @@ func (m *VirtualIPSpec) Size() (n int) { return n } +func (m *LoadBalancerPort) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Protocol != 0 { + n += 1 + sovApi(uint64(m.Protocol)) + } + if m.Port != 0 { + n += 1 + sovApi(uint64(m.Port)) + } + if m.EndPort != 0 { + n += 1 + sovApi(uint64(m.EndPort)) + } + return n +} + +func (m *LoadBalancerTargetSpec) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Ip) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } + if len(m.Ports) > 0 { + for _, e := range m.Ports { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } + return n +} + func (m *NetworkInterfaceSpec) Size() (n int) { if m == nil { return 0 @@ -6682,6 +6977,12 @@ func (m *NetworkInterfaceSpec) Size() (n int) { n += 1 + l + sovApi(uint64(l)) } } + if len(m.LoadBalancerTargets) > 0 { + for _, e := range m.LoadBalancerTargets { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } return n } @@ -7612,15 +7913,49 @@ func (this *VirtualIPSpec) String() string { }, "") return s } +func (this *LoadBalancerPort) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&LoadBalancerPort{`, + `Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `EndPort:` + fmt.Sprintf("%v", this.EndPort) + `,`, + `}`, + }, "") + return s +} +func (this *LoadBalancerTargetSpec) String() string { + if this == nil { + return "nil" + } + repeatedStringForPorts := "[]*LoadBalancerPort{" + for _, f := range this.Ports { + repeatedStringForPorts += strings.Replace(f.String(), "LoadBalancerPort", "LoadBalancerPort", 1) + "," + } + repeatedStringForPorts += "}" + s := strings.Join([]string{`&LoadBalancerTargetSpec{`, + `Ip:` + fmt.Sprintf("%v", this.Ip) + `,`, + `Ports:` + repeatedStringForPorts + `,`, + `}`, + }, "") + return s +} func (this *NetworkInterfaceSpec) String() string { if this == nil { return "nil" } + repeatedStringForLoadBalancerTargets := "[]*LoadBalancerTargetSpec{" + for _, f := range this.LoadBalancerTargets { + repeatedStringForLoadBalancerTargets += strings.Replace(f.String(), "LoadBalancerTargetSpec", "LoadBalancerTargetSpec", 1) + "," + } + repeatedStringForLoadBalancerTargets += "}" s := strings.Join([]string{`&NetworkInterfaceSpec{`, `Network:` + strings.Replace(this.Network.String(), "NetworkSpec", "NetworkSpec", 1) + `,`, `Ips:` + fmt.Sprintf("%v", this.Ips) + `,`, `VirtualIp:` + strings.Replace(this.VirtualIp.String(), "VirtualIPSpec", "VirtualIPSpec", 1) + `,`, `Prefixes:` + fmt.Sprintf("%v", this.Prefixes) + `,`, + `LoadBalancerTargets:` + repeatedStringForLoadBalancerTargets + `,`, `}`, }, "") return s @@ -9343,6 +9678,229 @@ func (m *VirtualIPSpec) Unmarshal(dAtA []byte) error { } return nil } +func (m *LoadBalancerPort) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LoadBalancerPort: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LoadBalancerPort: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) + } + m.Protocol = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Protocol |= Protocol(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndPort", wireType) + } + m.EndPort = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndPort |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LoadBalancerTargetSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LoadBalancerTargetSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LoadBalancerTargetSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ip = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ports = append(m.Ports, &LoadBalancerPort{}) + if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *NetworkInterfaceSpec) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -9508,6 +10066,40 @@ func (m *NetworkInterfaceSpec) Unmarshal(dAtA []byte) error { } m.Prefixes = append(m.Prefixes, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancerTargets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LoadBalancerTargets = append(m.LoadBalancerTargets, &LoadBalancerTargetSpec{}) + if err := m.LoadBalancerTargets[len(m.LoadBalancerTargets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) diff --git a/ori/apis/machine/v1alpha1/api.proto b/ori/apis/machine/v1alpha1/api.proto index 7c71e0a31..2cea99bfd 100644 --- a/ori/apis/machine/v1alpha1/api.proto +++ b/ori/apis/machine/v1alpha1/api.proto @@ -74,11 +74,29 @@ message VirtualIPSpec { string ip = 1; } +enum Protocol { + TCP = 0; + UDP = 1; + SCTP = 2; +} + +message LoadBalancerPort { + Protocol protocol = 1; + int32 port = 2; + int32 endPort = 3; +} + +message LoadBalancerTargetSpec { + string ip = 1; + repeated LoadBalancerPort ports = 2; +} + message NetworkInterfaceSpec { NetworkSpec network = 1; repeated string ips = 2; VirtualIPSpec virtual_ip = 3; repeated string prefixes = 4; + repeated LoadBalancerTargetSpec load_balancer_targets = 5; } message NetworkInterface {