...

Source file src/edge-infra.dev/pkg/edge/api/graph/resolver/cluster_orchestration.go

Documentation: edge-infra.dev/pkg/edge/api/graph/resolver

     1  package resolver
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  
     7  	"google.golang.org/grpc/codes"
     8  
     9  	gcperror "edge-infra.dev/pkg/edge/api/apierror/gcp"
    10  	"edge-infra.dev/pkg/edge/api/graph/mapper"
    11  	"edge-infra.dev/pkg/edge/api/graph/model"
    12  	"edge-infra.dev/pkg/edge/api/utils"
    13  	edgeCapabilities "edge-infra.dev/pkg/edge/capabilities"
    14  	chariotClientApi "edge-infra.dev/pkg/edge/chariot/client"
    15  	"edge-infra.dev/pkg/edge/constants"
    16  	"edge-infra.dev/pkg/edge/k8objectsutils"
    17  	"edge-infra.dev/pkg/sds/clustersecrets/breakglass"
    18  	"edge-infra.dev/pkg/sds/clustersecrets/grub"
    19  )
    20  
    21  func (r *Resolver) UpdateBootOptionsViaChariot(ctx context.Context, clusterEdgeID string, clusterConfig *model.ClusterConfig, operation chariotClientApi.Operation) error {
    22  	cluster, err := r.StoreClusterService.GetCluster(ctx, clusterEdgeID)
    23  	if err != nil {
    24  		return err
    25  	}
    26  
    27  	bootOptionsConfigMap := mapper.CreateBootOptionsConfigMap(clusterConfig)
    28  	bootOptionsBase64, err := utils.ConvertStructToBase64(bootOptionsConfigMap)
    29  	if err != nil {
    30  		return err
    31  	}
    32  
    33  	return r.sendChariotMessage(ctx, cluster.ProjectID, cluster.ClusterEdgeID, operation, bootOptionsBase64)
    34  }
    35  
    36  func (r *Resolver) UpdateTopologyInfoCMViaChariot(ctx context.Context, clusterEdgeID string, clusterConfig *model.ClusterConfig, operation chariotClientApi.Operation) error {
    37  	cluster, err := r.StoreClusterService.GetCluster(ctx, clusterEdgeID)
    38  	if err != nil {
    39  		return err
    40  	}
    41  	topologyConfigMap := mapper.CreateTopologyInfoConfigMap(*clusterConfig)
    42  	topologyConfigMapBase64, err := utils.ConvertStructToBase64(topologyConfigMap)
    43  	if err != nil {
    44  		return err
    45  	}
    46  
    47  	return r.sendChariotMessage(ctx, cluster.ProjectID, cluster.ClusterEdgeID, operation, topologyConfigMapBase64)
    48  }
    49  
    50  func (r *Resolver) DeleteClustersInfraAndGCPResources(ctx context.Context, cluster *model.Cluster) error {
    51  	errors := utils.NewErrorWrapper()
    52  
    53  	if err := r.deleteClusterSecretManagerSecrets(ctx, cluster); err != nil {
    54  		errors.AddError(err, "error deleting cluster secrets")
    55  	}
    56  
    57  	if err := r.ActivationCodeService.CleanupStore(ctx, cluster); err != nil {
    58  		errors.AddError(err, "error deleting clusters activation codes")
    59  	}
    60  	return errors.Errors
    61  }
    62  
    63  func (r *Resolver) UpdateClusterDefaultOptionalPallets(ctx context.Context, cluster *model.Cluster, fleetVersion, previousStoreVersion string) error {
    64  	// add default optional pallets to clusters for the updated fleet version
    65  	existingLabels, err := r.LabelService.GetLabels(ctx, &cluster.BannerEdgeID)
    66  	if err != nil {
    67  		return err
    68  	}
    69  
    70  	// get existing labels of type edge-capabilities
    71  	edgeCapabilityLabels := edgeCapabilities.GetCapabilityLabels(existingLabels, edgeCapabilities.DefaultStoreEdgeCapabilities...)
    72  
    73  	supportedEdgeCapabilityLabels, err := edgeCapabilities.GetCapabilityLabelsForSupportedVersion(edgeCapabilityLabels, fleetVersion, &previousStoreVersion)
    74  	if err != nil {
    75  		return err
    76  	}
    77  
    78  	for _, label := range supportedEdgeCapabilityLabels {
    79  		if err := r.LabelService.CreateClusterLabel(ctx, cluster.ClusterEdgeID, label.LabelEdgeID); err != nil {
    80  			return err
    81  		}
    82  	}
    83  	return nil
    84  }
    85  
    86  func isNotFound(err error) bool {
    87  	var gcpErr *gcperror.Error
    88  	return errors.As(err, &gcpErr) && gcpErr.Code == int(codes.NotFound)
    89  }
    90  
    91  func (r *Resolver) deleteClusterSecretManagerSecrets(ctx context.Context, cluster *model.Cluster) error {
    92  	allErrors := utils.NewErrorWrapper()
    93  
    94  	breakGlassPlainName := k8objectsutils.NameWithPrefix(breakglass.PlainSecretName, cluster.ClusterEdgeID)
    95  	if _, err := r.GCPService.DeleteSecret(ctx, breakGlassPlainName, cluster.ProjectID); err != nil && !isNotFound(err) {
    96  		allErrors.AddError(err, "could not delete plain breakglass secret manager secret")
    97  	}
    98  
    99  	breakGlassHashedName := k8objectsutils.NameWithPrefix(breakglass.HashedSecretName, cluster.ClusterEdgeID)
   100  	if _, err := r.GCPService.DeleteSecret(ctx, breakGlassHashedName, cluster.ProjectID); err != nil && !isNotFound(err) {
   101  		allErrors.AddError(err, "could not delete hashed breakglass secret manager secret")
   102  	}
   103  
   104  	grubPlainName := k8objectsutils.NameWithPrefix(grub.PlainSecretName, cluster.ClusterEdgeID)
   105  	if _, err := r.GCPService.DeleteSecret(ctx, grubPlainName, cluster.ProjectID); err != nil && !isNotFound(err) {
   106  		allErrors.AddError(err, "could not delete plain grub secret manager secret")
   107  	}
   108  
   109  	grubHashedName := k8objectsutils.NameWithPrefix(grub.HashedSecretName, cluster.ClusterEdgeID)
   110  	if _, err := r.GCPService.DeleteSecret(ctx, grubHashedName, cluster.ProjectID); err != nil && !isNotFound(err) {
   111  		allErrors.AddError(err, "could not delete hashed grub secret manager secret")
   112  	}
   113  
   114  	return allErrors.GetErrors()
   115  }
   116  
   117  func (r *Resolver) registerK8sDefaultSubnets(ctx context.Context, clusterEdgeID string) error {
   118  	k8sDefaultSubnets := []*model.CreateNetworkServiceInfo{
   119  		{
   120  			ServiceType: constants.ServiceTypePodNetworkCIDR,
   121  			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypePodNetworkCIDR],
   122  			Family:      "inet",
   123  		},
   124  		{
   125  			ServiceType: constants.ServiceTypeServiceNetworkCIDR,
   126  			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypeServiceNetworkCIDR],
   127  			Family:      "inet",
   128  		},
   129  		{
   130  			ServiceType: constants.ServiceTypeClusterDNS,
   131  			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypeClusterDNS],
   132  			Family:      "inet",
   133  		},
   134  		{
   135  			ServiceType: constants.ServiceTypeEgressTunnelsCIDR,
   136  			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypeEgressTunnelsCIDR],
   137  			Family:      "inet",
   138  		},
   139  	}
   140  	_, err := r.StoreClusterService.CreateClusterNetworkServices(ctx, clusterEdgeID, k8sDefaultSubnets)
   141  	return err
   142  }
   143  

View as plain text