image: replace "upload {aws|azure|gcp}" with uplosi

This commit is contained in:
Malte Poll 2024-01-04 16:59:31 +01:00
parent fb392c2d50
commit b7bab7c3c8
22 changed files with 252 additions and 2478 deletions

View file

@ -8,9 +8,8 @@ package cmd
import (
"errors"
"os"
"path/filepath"
"time"
"strings"
"github.com/edgelesssys/constellation/v2/internal/api/versionsapi"
"github.com/edgelesssys/constellation/v2/internal/cloud/cloudprovider"
@ -18,200 +17,6 @@ import (
"go.uber.org/zap/zapcore"
)
type commonFlags struct {
rawImage string
pki string
provider cloudprovider.Provider
attestationVariant string
secureBoot bool
version versionsapi.Version
timestamp time.Time
region string
bucket string
distributionID string
out string
logLevel zapcore.Level
}
func parseCommonFlags(cmd *cobra.Command) (commonFlags, error) {
workspaceDir := os.Getenv("BUILD_WORKSPACE_DIRECTORY")
rawImage, err := cmd.Flags().GetString("raw-image")
if err != nil {
return commonFlags{}, err
}
pki, err := cmd.Flags().GetString("pki")
if err != nil {
return commonFlags{}, err
}
if pki == "" {
pki = filepath.Join(workspaceDir, "image/pki")
}
attestationVariant, err := cmd.Flags().GetString("attestation-variant")
if err != nil {
return commonFlags{}, err
}
secureBoot, err := cmd.Flags().GetBool("secure-boot")
if err != nil {
return commonFlags{}, err
}
version, err := cmd.Flags().GetString("version")
if err != nil {
return commonFlags{}, err
}
ver, err := versionsapi.NewVersionFromShortPath(version, versionsapi.VersionKindImage)
if err != nil {
return commonFlags{}, err
}
timestamp, err := cmd.Flags().GetString("timestamp")
if err != nil {
return commonFlags{}, err
}
if timestamp == "" {
timestamp = time.Now().Format("2006-01-02T15:04:05Z07:00")
}
timestmp, err := time.Parse("2006-01-02T15:04:05Z07:00", timestamp)
if err != nil {
return commonFlags{}, err
}
region, err := cmd.Flags().GetString("region")
if err != nil {
return commonFlags{}, err
}
bucket, err := cmd.Flags().GetString("bucket")
if err != nil {
return commonFlags{}, err
}
distributionID, err := cmd.Flags().GetString("distribution-id")
if err != nil {
return commonFlags{}, err
}
out, err := cmd.Flags().GetString("out")
if err != nil {
return commonFlags{}, err
}
verbose, err := cmd.Flags().GetBool("verbose")
if err != nil {
return commonFlags{}, err
}
logLevel := zapcore.InfoLevel
if verbose {
logLevel = zapcore.DebugLevel
}
return commonFlags{
rawImage: rawImage,
pki: pki,
attestationVariant: attestationVariant,
secureBoot: secureBoot,
version: ver,
timestamp: timestmp,
region: region,
bucket: bucket,
distributionID: distributionID,
out: out,
logLevel: logLevel,
}, nil
}
type awsFlags struct {
commonFlags
awsRegion string
awsBucket string
}
func parseAWSFlags(cmd *cobra.Command) (awsFlags, error) {
common, err := parseCommonFlags(cmd)
if err != nil {
return awsFlags{}, err
}
awsRegion, err := cmd.Flags().GetString("aws-region")
if err != nil {
return awsFlags{}, err
}
awsBucket, err := cmd.Flags().GetString("aws-bucket")
if err != nil {
return awsFlags{}, err
}
common.provider = cloudprovider.AWS
return awsFlags{
commonFlags: common,
awsRegion: awsRegion,
awsBucket: awsBucket,
}, nil
}
type azureFlags struct {
commonFlags
azSubscription string
azLocation string
azResourceGroup string
}
func parseAzureFlags(cmd *cobra.Command) (azureFlags, error) {
common, err := parseCommonFlags(cmd)
if err != nil {
return azureFlags{}, err
}
azSubscription, err := cmd.Flags().GetString("az-subscription")
if err != nil {
return azureFlags{}, err
}
azLocation, err := cmd.Flags().GetString("az-location")
if err != nil {
return azureFlags{}, err
}
azResourceGroup, err := cmd.Flags().GetString("az-resource-group")
if err != nil {
return azureFlags{}, err
}
common.provider = cloudprovider.Azure
return azureFlags{
commonFlags: common,
azSubscription: azSubscription,
azLocation: azLocation,
azResourceGroup: azResourceGroup,
}, nil
}
type gcpFlags struct {
commonFlags
gcpProject string
gcpLocation string
gcpBucket string
}
func parseGCPFlags(cmd *cobra.Command) (gcpFlags, error) {
common, err := parseCommonFlags(cmd)
if err != nil {
return gcpFlags{}, err
}
gcpProject, err := cmd.Flags().GetString("gcp-project")
if err != nil {
return gcpFlags{}, err
}
gcpLocation, err := cmd.Flags().GetString("gcp-location")
if err != nil {
return gcpFlags{}, err
}
gcpBucket, err := cmd.Flags().GetString("gcp-bucket")
if err != nil {
return gcpFlags{}, err
}
common.provider = cloudprovider.GCP
return gcpFlags{
commonFlags: common,
gcpProject: gcpProject,
gcpLocation: gcpLocation,
gcpBucket: gcpBucket,
}, nil
}
type s3Flags struct {
region string
bucket string
@ -357,3 +162,130 @@ func parseEnvelopeMeasurementsFlags(cmd *cobra.Command) (envelopeMeasurementsFla
logLevel: logLevel,
}, nil
}
type uplosiFlags struct {
rawImage string
provider cloudprovider.Provider
version versionsapi.Version
attestationVariant string
out string
uplosiPath string
// archiver flags
region string
bucket string
distributionID string
logLevel zapcore.Level
}
func parseUplosiFlags(cmd *cobra.Command) (uplosiFlags, error) {
rawImage, err := cmd.Flags().GetString("raw-image")
if err != nil {
return uplosiFlags{}, err
}
rawImage, err = filepath.Abs(rawImage)
if err != nil {
return uplosiFlags{}, err
}
// extract csp, attestation variant, and stream from the raw image name
// format: <csp>_<attestation-variant>_<stream>/constellation.raw
var guessedCSP, guessedAttestationVariant, guessedStream string
pathComponents := strings.Split(filepath.ToSlash(rawImage), "/")
if len(pathComponents) >= 2 && pathComponents[len(pathComponents)-1] == "constellation.raw" {
imageMetadata := pathComponents[len(pathComponents)-2]
imageMetadataComponents := strings.Split(imageMetadata, "_")
if len(imageMetadataComponents) == 3 {
guessedCSP = imageMetadataComponents[0]
guessedAttestationVariant = imageMetadataComponents[1]
guessedStream = imageMetadataComponents[2]
}
}
csp, err := cmd.Flags().GetString("csp")
if err != nil || csp == "" {
csp = guessedCSP
}
if csp == "" {
if err != nil {
return uplosiFlags{}, err
}
return uplosiFlags{}, errors.New("csp is required")
}
provider := cloudprovider.FromString(csp)
ref, err := cmd.Flags().GetString("ref")
if err != nil {
return uplosiFlags{}, err
}
stream, err := cmd.Flags().GetString("stream")
if err != nil || stream == "" {
stream = guessedStream
}
if stream == "" {
if err != nil {
return uplosiFlags{}, err
}
return uplosiFlags{}, errors.New("stream is required")
}
version, err := cmd.Flags().GetString("version")
if err != nil {
return uplosiFlags{}, err
}
ver, err := versionsapi.NewVersion(ref, stream, version, versionsapi.VersionKindImage)
if err != nil {
return uplosiFlags{}, err
}
attestationVariant, err := cmd.Flags().GetString("attestation-variant")
if err != nil || attestationVariant == "" {
attestationVariant = guessedAttestationVariant
}
if attestationVariant == "" {
if err != nil {
return uplosiFlags{}, err
}
return uplosiFlags{}, errors.New("attestation-variant is required")
}
out, err := cmd.Flags().GetString("out")
if err != nil {
return uplosiFlags{}, err
}
uplosiPath, err := cmd.Flags().GetString("uplosi-path")
if err != nil {
return uplosiFlags{}, err
}
region, err := cmd.Flags().GetString("region")
if err != nil {
return uplosiFlags{}, err
}
bucket, err := cmd.Flags().GetString("bucket")
if err != nil {
return uplosiFlags{}, err
}
distributionID, err := cmd.Flags().GetString("distribution-id")
if err != nil {
return uplosiFlags{}, err
}
verbose, err := cmd.Flags().GetBool("verbose")
if err != nil {
return uplosiFlags{}, err
}
logLevel := zapcore.InfoLevel
if verbose {
logLevel = zapcore.DebugLevel
}
return uplosiFlags{
rawImage: rawImage,
provider: provider,
version: ver,
attestationVariant: attestationVariant,
out: out,
uplosiPath: uplosiPath,
region: region,
bucket: bucket,
distributionID: distributionID,
logLevel: logLevel,
}, nil
}