diff --git a/go.mod b/go.mod index 789f142e7..7c2ea4311 100644 --- a/go.mod +++ b/go.mod @@ -46,6 +46,7 @@ require golang.org/x/sys v0.4.0 // indirect require ( github.com/mitchellh/hashstructure/v2 v2.0.2 github.com/otiai10/copy v1.2.0 + golang.org/x/sync v0.1.0 ) require ( @@ -206,7 +207,6 @@ require ( golang.org/x/exp v0.0.0-20221002003631-540bb7301a08 // indirect golang.org/x/net v0.5.0 // indirect golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2 // indirect - golang.org/x/sync v0.1.0 // indirect golang.org/x/term v0.4.0 // indirect golang.org/x/text v0.6.0 // indirect golang.org/x/time v0.0.0-20220210224613-90d013bbcef8 // indirect diff --git a/internal/testutils/testutils.go b/internal/testutils/testutils.go index ec3d35add..9fd28b6bc 100644 --- a/internal/testutils/testutils.go +++ b/internal/testutils/testutils.go @@ -3,8 +3,8 @@ package testutils import ( "encoding/json" "fmt" + "io" "io/fs" - "io/ioutil" "net/http" "net/http/httptest" "net/url" @@ -12,19 +12,30 @@ import ( "path" "path/filepath" "strings" + "time" "github.com/docker/distribution/manifest" "github.com/google/go-containerregistry/pkg/crane" "github.com/google/go-containerregistry/pkg/name" + v1 "github.com/google/go-containerregistry/pkg/v1" "github.com/google/go-containerregistry/pkg/v1/empty" "github.com/google/go-containerregistry/pkg/v1/layout" + "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/google/go-containerregistry/pkg/v1/random" "github.com/google/go-containerregistry/pkg/v1/remote" + "github.com/google/go-containerregistry/pkg/v1/types" ) // WriteTestImage will use go-containerregistry to push a test image to // an httptest.Server and will write the image to an OCI layout if dir is not "". func WriteTestImage(testServer *httptest.Server, dir string) (string, error) { - u, err := url.Parse(testServer.URL) + return WriteTestImageWithURL(testServer.URL, dir) +} + +// WriteTestImageWithURL is similar to WriteTestImage, but is useful when testing +// with external registries rather than a httptest.Server +func WriteTestImageWithURL(URL string, dir string) (string, error) { + u, err := url.Parse(URL) if err != nil { return "", err } @@ -37,17 +48,18 @@ func WriteTestImage(testServer *httptest.Server, dir string) (string, error) { return "", err } i, _ := crane.Image(c) - if err := crane.Push(i, tag.String()); err != nil { - return "", err - } + if dir != "" { + // create a new layout.Path and append the image to it lp, err := layout.Write(dir, empty.Index) if err != nil { return "", err } + // write the image into the layout path if err := lp.AppendImage(i); err != nil { return "", err } + // reload the path as an index and "push" it to remote idx, err := lp.ImageIndex() if err != nil { return "", err @@ -55,6 +67,109 @@ func WriteTestImage(testServer *httptest.Server, dir string) (string, error) { if err := remote.WriteIndex(tag, idx); err != nil { return "", err } + } else { + // push image to remote + if err := crane.Push(i, tag.String()); err != nil { + return "", err + } + } + return targetRef, nil +} + +// WriteMultiarchTestImageWithURL will use go-containerregistry to push a multi arch test image to +// an httptest.Server and will write the image to an OCI layout if dir is not "". +func WriteMultiArchTestImage(testServer *httptest.Server, dir string) (string, error) { + return WriteMultiArchTestImageWithURL(testServer.URL, dir) +} + +// WriteMultiArchTestImageWithURL is similar to WriteMultiArchTestImage, but is useful when testing +// with external registries rather than a httptest.Server +func WriteMultiArchTestImageWithURL(URL string, dir string) (string, error) { + u, err := url.Parse(URL) + if err != nil { + return "", err + } + targetRef := fmt.Sprintf("%s/bar:foo", u.Host) + tag, err := name.NewTag(targetRef) + if err != nil { + return "", err + } + makeLayer := func() v1.Layer { + layer, _ := random.Layer(100, types.DockerLayer) + if err != nil { + // this is a hack, but it should not happen + panic(err) + } + return layer + } + img1, err := mutate.ConfigFile(empty.Image, &v1.ConfigFile{OS: "linux", Architecture: "amd64"}) + if err != nil { + return "", err + } + img1, err = mutate.Append(img1, mutate.Addendum{ + Layer: makeLayer(), + History: v1.History{ + Author: "random.Image", + Comment: fmt.Sprintf("this is a random history %d of %d", 1, 1), + CreatedBy: "random", + Created: v1.Time{Time: time.Now()}, + }, + // MediaType: types.DockerManifestSchema2, + }) + img2, err := mutate.ConfigFile(empty.Image, &v1.ConfigFile{OS: "linux", Architecture: "ppc64le"}) + if err != nil { + return "", err + } + img2, err = mutate.Append(img2, mutate.Addendum{ + Layer: makeLayer(), + History: v1.History{ + Author: "random.Image", + Comment: fmt.Sprintf("this is a random history %d of %d", 1, 1), + CreatedBy: "random", + Created: v1.Time{Time: time.Now()}, + }, + // MediaType: types.DockerManifestSchema2, + }) + ii := mutate.AppendManifests(empty.Index, + mutate.IndexAddendum{ + Add: img1, + Descriptor: v1.Descriptor{ + Platform: &v1.Platform{ + OS: "linux", + Architecture: "amd64", + }, + }, + }, + mutate.IndexAddendum{ + Add: img2, + Descriptor: v1.Descriptor{ + Platform: &v1.Platform{ + OS: "linux", + Architecture: "ppc64le", + }, + }, + }, + ) + // update the MediaType for this index + ii = mutate.IndexMediaType(ii, types.DockerManifestList) + if dir != "" { + // "wrap" the newly created index in a new index (i.e. create manifest list indirection) + // NOTE: manifest list indirection is only useful for OCI layouts... this is + // not supported when pushing to a remote registry + oci_ii := mutate.AppendManifests(empty.Index, mutate.IndexAddendum{ + Add: ii, + Descriptor: v1.Descriptor{ + MediaType: types.DockerManifestList, + }, + }) + _, err := layout.Write(dir, oci_ii) + if err != nil { + return "", err + } + } + // now "push" to remote + if err := remote.WriteIndex(tag, ii); err != nil { + return "", err } return targetRef, nil } @@ -74,7 +189,7 @@ func RegistryFromFiles(source string) http.HandlerFunc { case "manifests": if f, err := dir.Open(req.URL.Path); err == nil { defer f.Close() - if data, err := ioutil.ReadAll(f); err == nil { + if data, err := io.ReadAll(f); err == nil { var versioned manifest.Versioned if err = json.Unmarshal(data, &versioned); err == nil { w.Header().Set("Content-Type", versioned.MediaType) @@ -110,13 +225,13 @@ func LocalMirrorFromFiles(source string, destination string) error { default: newSource := filepath.Join(source, relPath) cleanSource := filepath.Clean(newSource) - data, err := ioutil.ReadFile(cleanSource) + data, err := os.ReadFile(cleanSource) if err != nil { return err } newDest := filepath.Join(destination, relPath) cleanDest := filepath.Clean(newDest) - return ioutil.WriteFile(cleanDest, data, 0600) + return os.WriteFile(cleanDest, data, 0600) } return nil }) diff --git a/pkg/cli/mirror/catalog_images.go b/pkg/cli/mirror/catalog_images.go index dd4e342a4..e93080569 100644 --- a/pkg/cli/mirror/catalog_images.go +++ b/pkg/cli/mirror/catalog_images.go @@ -14,6 +14,7 @@ import ( v1 "github.com/google/go-containerregistry/pkg/v1" "github.com/google/go-containerregistry/pkg/v1/layout" "github.com/openshift/library-go/pkg/image/reference" + "github.com/openshift/oc/pkg/cli/image/imagesource" "github.com/operator-framework/operator-registry/pkg/containertools" "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "k8s.io/klog/v2" @@ -22,7 +23,6 @@ import ( "github.com/openshift/oc-mirror/pkg/config" "github.com/openshift/oc-mirror/pkg/image" "github.com/openshift/oc-mirror/pkg/image/builder" - "github.com/openshift/oc/pkg/cli/image/imagesource" ) // unpackCatalog will unpack file-based catalogs if they exists @@ -40,6 +40,22 @@ func (o *MirrorOptions) unpackCatalog(dstDir string, filesInArchive map[string]s return found, nil } +/* +rebuildCatalogs will modify an OCI catalog in /src/catalogs//layout with +the index.json files found in /src/catalogs//index/index.json + +# Arguments + +• ctx: cancellation context + +• dstDir: the path to where the config.SourceDir resides + +# Returns + +• image.TypedImageMapping: the source/destination mapping for the catalog + +• error: non-nil if error occurs, nil otherwise +*/ func (o *MirrorOptions) rebuildCatalogs(ctx context.Context, dstDir string) (image.TypedImageMapping, error) { refs := image.TypedImageMapping{} var err error @@ -68,12 +84,20 @@ func (o *MirrorOptions) rebuildCatalogs(ctx context.Context, dstDir string) (ima // Using that path to determine the corresponding catalog image for processing. slashPath := filepath.ToSlash(fpath) if base := path.Base(slashPath); base == "index.json" { + // remove the index.json from the path + // results in /src/catalogs//index slashPath = path.Dir(slashPath) + // remove the index folder from the path + // results in /src/catalogs/ slashPath = strings.TrimSuffix(slashPath, config.IndexDir) + // remove the /src/catalogs from the path to arrive at repoPath := strings.TrimPrefix(slashPath, fmt.Sprintf("%s/%s/", dstDir, config.CatalogsDir)) + // get the repo namespace and id (where ID is a SHA or tag) + // example: foo.com/foo/bar/ regRepoNs, id := path.Split(path.Dir(repoPath)) regRepoNs = path.Clean(regRepoNs) + // reconstitute the path into a valid docker ref var img string if strings.Contains(id, ":") { // Digest. @@ -85,6 +109,14 @@ func (o *MirrorOptions) rebuildCatalogs(ctx context.Context, dstDir string) (ima ctlgRef := image.TypedImage{} ctlgRef.Type = imagesource.DestinationRegistry sourceRef, err := image.ParseReference(img) + // since we can't really tell if the "img" reference originated from an actual docker + // reference or from an OCI file path that approximates a docker reference, ParseReference + // might not lowercase the name and namespace values which is required by the + // docker reference spec (see https://github.com/distribution/distribution/blob/main/reference/reference.go). + // Therefore we lower case name and namespace here to make sure it's done. + sourceRef.Ref.Name = strings.ToLower(sourceRef.Ref.Name) + sourceRef.Ref.Namespace = strings.ToLower(sourceRef.Ref.Namespace) + if err != nil { return fmt.Errorf("error parsing index dir path %q as image %q: %v", fpath, img, err) } @@ -107,10 +139,12 @@ func (o *MirrorOptions) rebuildCatalogs(ctx context.Context, dstDir string) (ima return nil, err } + // update the catalogs in the OCI layout directory and push them to their destination if err := o.processCatalogRefs(ctx, catalogsByImage); err != nil { return nil, err } + // use the resolver to obtain the digests of the newly pushed images resolver, err := containerdregistry.NewResolver("", o.DestSkipTLS, o.DestPlainHTTP, nil) if err != nil { return nil, fmt.Errorf("error creating image resolver: %v", err) @@ -129,6 +163,19 @@ func (o *MirrorOptions) rebuildCatalogs(ctx context.Context, dstDir string) (ima return refs, nil } +/* +processCatalogRefs uses the image builder to update a given image using the data provided in catalogRefs. + +# Arguments + +• ctx: cancellation context + +• catalogsByImage: key is catalog destination reference, value is /src/catalogs/ + +# Returns + +• error: non-nil if error occurs, nil otherwise +*/ func (o *MirrorOptions) processCatalogRefs(ctx context.Context, catalogsByImage map[image.TypedImage]string) error { for ctlgRef, artifactDir := range catalogsByImage { // Always build the catalog image with the new declarative config catalog diff --git a/pkg/cli/mirror/create.go b/pkg/cli/mirror/create.go index ac1befcd5..958b53bae 100644 --- a/pkg/cli/mirror/create.go +++ b/pkg/cli/mirror/create.go @@ -8,6 +8,8 @@ import ( "path/filepath" "time" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/layout" "github.com/google/uuid" "k8s.io/klog/v2" @@ -91,7 +93,32 @@ func (o *MirrorOptions) Create(ctx context.Context, cfg v1alpha2.ImageSetConfigu } } -func (o *MirrorOptions) run(ctx context.Context, cfg *v1alpha2.ImageSetConfiguration, meta v1alpha2.Metadata, operatorPlan operatorFunc) (image.TypedImageMapping, error) { +/* +operatorFunc is a function signature for operator planning operations + +# Arguments + +• ctx: A cancellation context + +• cfg: An ImageSetConfiguration that should be processed + +# Returns + +• image.TypedImageMapping: Any src->dest mappings found during planning. Will be nil if an error occurs, non-nil otherwise. + +• error: non-nil if an error occurs, nil otherwise +*/ +type operatorFunc func( + ctx context.Context, + cfg v1alpha2.ImageSetConfiguration, +) (image.TypedImageMapping, error) + +func (o *MirrorOptions) run( + ctx context.Context, + cfg *v1alpha2.ImageSetConfiguration, + meta v1alpha2.Metadata, + operatorPlan operatorFunc, +) (image.TypedImageMapping, error) { mmappings := image.TypedImageMapping{} @@ -166,14 +193,72 @@ func (o *MirrorOptions) createOlmArtifactsForOCI(ctx context.Context, cfg v1alph return err } + // setup where the FBC content will be written to catalogContentsDir := filepath.Join(artifactsFolderName, ctlg.Ref.Name) + // obtain the path to where the OCI image reference resides + layoutPath := layout.Path(v1alpha2.TrimProtocol(ctlg.OCIFBCPath)) + + // get its index.json and obtain its manifest + rootIndex, err := layoutPath.ImageIndex() + if err != nil { + return err + } + rootIndexManifest, err := rootIndex.IndexManifest() + if err != nil { + return err + } + + // attempt to find the first image reference in the layout... + // for a manifest list only search one level deep. + var img v1.Image + loop: + for _, descriptor := range rootIndexManifest.Manifests { + + if descriptor.MediaType.IsIndex() { + // follow the descriptor using its digest to get the referenced index and its manifest + childIndex, err := rootIndex.ImageIndex(descriptor.Digest) + if err != nil { + return err + } + childIndexManifest, err := childIndex.IndexManifest() + if err != nil { + return err + } + + // at this point, find the first image and store it for later if possible + for _, childDescriptor := range childIndexManifest.Manifests { + if childDescriptor.MediaType.IsImage() { + img, err = childIndex.Image(childDescriptor.Digest) + if err != nil { + return err + } + // no further processing necessary + break loop + } + } - _, err = o.findFBCConfig(ctx, v1alpha2.TrimProtocol(operator.Catalog), catalogContentsDir) + } else if descriptor.MediaType.IsImage() { + // this is a direct reference to an image, so just store it for later + img, err = rootIndex.Image(descriptor.Digest) + if err != nil { + return err + } + // no further processing necessary + break loop + } + } + // if we get here and no image was found bail out + if img == nil { + return fmt.Errorf("unable to obtain image for %s", operator.Catalog) + } + // fullArtifactPath is set to /olm_artifacts// + fullArtifactPath, err := extractDeclarativeConfigFromImage(img, catalogContentsDir) if err != nil { return err } + + // store the full artifact path for later so we don't have to recalculate the path. + o.operatorCatalogToFullArtifactPath[operator.Catalog] = fullArtifactPath } return nil } - -type operatorFunc func(ctx context.Context, cfg v1alpha2.ImageSetConfiguration) (image.TypedImageMapping, error) diff --git a/pkg/cli/mirror/create_test.go b/pkg/cli/mirror/create_test.go index 0553a75b5..d7ffcc0cb 100644 --- a/pkg/cli/mirror/create_test.go +++ b/pkg/cli/mirror/create_test.go @@ -112,7 +112,7 @@ func TestCreateOlmArtifactsForOCI(t *testing.T) { }, }, }, - expectedErr: "unable to get OCI Image from oci:: open index.json: no such file or directory", + expectedErr: "open index.json: no such file or directory", }, } @@ -129,7 +129,8 @@ func TestCreateOlmArtifactsForOCI(t *testing.T) { ErrOut: os.Stderr, }, }, - OutputDir: path, + OutputDir: path, + operatorCatalogToFullArtifactPath: map[string]string{}, } for _, c := range cases { diff --git a/pkg/cli/mirror/fbc_operators.go b/pkg/cli/mirror/fbc_operators.go index a237c86a0..a362d0bd5 100644 --- a/pkg/cli/mirror/fbc_operators.go +++ b/pkg/cli/mirror/fbc_operators.go @@ -2,33 +2,35 @@ package mirror import ( "archive/tar" - "compress/gzip" + "bytes" "context" "crypto/sha256" - "encoding/json" "errors" "fmt" "io" "os" "path/filepath" "strings" + "sync" imagecopy "github.com/containers/image/v5/copy" - "github.com/containers/image/v5/oci/layout" - "github.com/containers/image/v5/pkg/sysregistriesv2" - "github.com/opencontainers/go-digest" - "github.com/containers/image/v5/manifest" "github.com/containers/image/v5/pkg/cli/environment" + "github.com/containers/image/v5/pkg/sysregistriesv2" "github.com/containers/image/v5/signature" "github.com/containers/image/v5/transports/alltransports" "github.com/containers/image/v5/types" - "github.com/openshift/oc-mirror/pkg/api/v1alpha2" - "github.com/openshift/oc-mirror/pkg/image" - "github.com/openshift/oc-mirror/pkg/metadata/storage" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/opencontainers/go-digest" "github.com/operator-framework/operator-registry/alpha/declcfg" + "github.com/operator-framework/operator-registry/pkg/containertools" "k8s.io/klog/v2" "sigs.k8s.io/yaml" + + "github.com/openshift/oc-mirror/pkg/api/v1alpha2" + "github.com/openshift/oc-mirror/pkg/image" + "github.com/openshift/oc-mirror/pkg/metadata/storage" ) const ( @@ -37,7 +39,6 @@ const ( configPath string = "configs/" catalogJSON string = "/catalog.json" relatedImages string = "relatedImages" - configsLabel string = "operators.operatorframework.io.index.configs.v1" artifactsFolderName string = "olm_artifacts" ocpRelease string = "release" ocpReleaseImages string = "release-images" @@ -130,7 +131,7 @@ func (o *MirrorOptions) generateSrcToFileMapping(ctx context.Context, relatedIma return mapping, nil } -func (o *MirrorOptions) addRelatedImageToMapping(ctx context.Context, mapping image.TypedImageMapping, img declcfg.RelatedImage, destReg, namespace string) error { +func (o *MirrorOptions) addRelatedImageToMapping(ctx context.Context, mapping *sync.Map, img declcfg.RelatedImage, destReg, namespace string) error { if img.Image == "" { klog.Warningf("invalid related image %s: reference empty", img.Name) return nil @@ -152,7 +153,10 @@ func (o *MirrorOptions) addRelatedImageToMapping(ctx context.Context, mapping im // i.Image is coming from a declarativeConfig (ClusterServiceVersion) it's therefore always a docker ref mirroredImage, err := findFirstAvailableMirror(ctx, reg.Mirrors, dockerPrefix+img.Image, reg.Prefix, o.remoteRegFuncs) if err == nil { - img.Image = mirroredImage + from = mirroredImage + } else { + // verbose log so we know when we had no mirror hits + klog.V(3).Infof("Cannot find mirror for %s: %s", img.Image, err) } } @@ -203,7 +207,7 @@ func (o *MirrorOptions) addRelatedImageToMapping(ctx context.Context, mapping im TypedImageReference: dstTIR, Category: v1alpha2.TypeOperatorRelatedImage, } - mapping[srcTI] = dstTI + mapping.Store(srcTI, dstTI) return nil } @@ -299,95 +303,103 @@ func addCatalogToMapping(catalogMapping image.TypedImageMapping, srcOperator v1a return nil } -// findFBCConfig function to find the layer from the catalog -// that has the file based configuration -func (o *MirrorOptions) findFBCConfig(ctx context.Context, imagePath, catalogContentsPath string) (string, error) { - // read the index.json of the catalog - srcImg, err := getOCIImgSrcFromPath(ctx, imagePath) - if err != nil { - return "", err - } - manifest, err := getManifest(ctx, srcImg) - if err != nil { - return "", err +/* +extractDeclarativeConfigFromImage obtains a DeclarativeConfig instance from an image + +# Arguments + +• img: the image to pull a DeclarativeConfig out of + +• extractedImageDir: the location where the DeclarativeConfig should be placed upon extraction. +Typically /olm_artifacts/. + +# Returns + +• string: path to the folder containing the DeclarativeConfig if no error occurred, otherwise empty string. +The config directory from img is determined and appended to extractedImageDir. +Typically results in /olm_artifacts// + +• error: non-nil if an error occurred, nil otherwise +*/ +func extractDeclarativeConfigFromImage(img v1.Image, extractedImageDir string) (string, error) { + if img == nil { + return "", errors.New("unable to extract DeclarativeConfig because no image was provided") } - //Use the label in the config layer to determine the - //folder containing the related images, when untarring layers - cfgDirName, err := getConfigPathFromConfigLayer(imagePath, string(manifest.ConfigInfo().Digest)) + config, err := img.ConfigFile() if err != nil { return "", err } - // iterate through each layer + configsPrefix := "configs/" + if config.Config.Labels != nil { + label := config.Config.Labels[containertools.ConfigsLocationLabel] + if label != "" { + // strip beginning slash since this would prevent the configsPrefix from matching later on + label = strings.TrimPrefix(label, "/") + // since configsPrefix is supposed to be a directory, put in the ending slash if its not already present. + if !strings.HasSuffix(label, "/") { + label = label + "/" + } + configsPrefix = label + } + } + returnPath := filepath.Join(extractedImageDir, configsPrefix) + + tr := tar.NewReader(mutate.Extract(img)) + for { + header, err := tr.Next() + + // break the infinite loop when EOF + if errors.Is(err, io.EOF) { + break + } - for _, layer := range manifest.LayerInfos() { - layerSha := layer.Digest.String() - layerDirName := layerSha[7:] - r, err := os.Open(imagePath + blobsPath + layerDirName) + // skip the file if it is a directory or not in the configs dir + if !strings.HasPrefix(header.Name, configsPrefix) || header.FileInfo().IsDir() { + continue + } + + var buf bytes.Buffer + _, err = buf.ReadFrom(tr) if err != nil { return "", err } - // untar if it is the FBC - err = UntarLayers(r, catalogContentsPath, cfgDirName) + + targetFileName := filepath.Join(extractedImageDir, header.Name) + bytes := buf.Bytes() + + baseDir := filepath.Dir(targetFileName) + err = os.MkdirAll(baseDir, 0755) if err != nil { return "", err } - } - cfgContentsPath := filepath.Join(catalogContentsPath, cfgDirName) - f, err := os.Open(cfgContentsPath) - if err != nil { - return "", fmt.Errorf("unable to open temp folder containing extracted catalogs %s: %w", cfgContentsPath, err) - } - contents, err := f.Readdir(0) - if err != nil { - return "", fmt.Errorf("unable to read temp folder containing extracted catalogs %s: %w", cfgContentsPath, err) - } - if len(contents) == 0 { - return "", fmt.Errorf("no packages found in catalog") - } - return cfgContentsPath, nil -} -// getCatalogConfigPath takes an OCI FBC image as an input, -// it reads the manifest, then the config layer, -// more specifically the label `configLabel` -// and returns the value of that label -// The function fails if more than one manifest exist in the image -func (o *MirrorOptions) GetCatalogConfigPath(ctx context.Context, imagePath string) (string, error) { - // read the index.json of the catalog - srcImg, err := getOCIImgSrcFromPath(ctx, imagePath) - if err != nil { - return "", err - } - manifest, err := getManifest(ctx, srcImg) - if err != nil { - return "", err - } + f, err := os.Create(targetFileName) + if err == nil { + defer f.Close() + } else { + return "", err + } - //Use the label in the config layer to determine the - //folder containing the related images, when untarring layers - cfgDirName, err := getConfigPathFromConfigLayer(imagePath, string(manifest.ConfigInfo().Digest)) - if err != nil { - return "", err + _, err = f.Write(bytes) + if err != nil { + return "", err + } } - return cfgDirName, nil -} - -func getConfigPathFromConfigLayer(imagePath, configSha string) (string, error) { - var cfg *manifest.Schema2V1Image - configLayerDir := configSha[7:] - cfgBlob, err := os.ReadFile(filepath.Join(v1alpha2.TrimProtocol(imagePath), blobsPath, configLayerDir)) - if err != nil { - return "", fmt.Errorf("unable to read the config blob %s from the oci image: %w", configLayerDir, err) + // check for the folder (it should exist if we found something) + _, err = os.Stat(returnPath) + if errors.Is(err, os.ErrNotExist) { + return "", fmt.Errorf("directory not found after extracting %q within image", configsPrefix) } - err = json.Unmarshal(cfgBlob, &cfg) + // folder itself should contain data + dirs, err := os.ReadDir(returnPath) if err != nil { - return "", fmt.Errorf("problem unmarshaling config blob in %s: %w", configLayerDir, err) + return "", err } - if dirName, ok := cfg.Config.Labels[configsLabel]; ok { - return dirName, nil + if len(dirs) == 0 { + return "", fmt.Errorf("no content found at %q within image", configsPrefix) } - return "", fmt.Errorf("label %s not found in config blob %s", configsLabel, configLayerDir) + return returnPath, nil } // getRelatedImages reads a directory containing an FBC catalog () unpacked contents @@ -456,91 +468,6 @@ func findFirstAvailableMirror(ctx context.Context, mirrors []sysregistriesv2.End return "", finalError } -// getManifest reads the manifest of the OCI FBC image -// and returns it as a go structure of type manifest.Manifest -func getManifest(ctx context.Context, imgSrc types.ImageSource) (manifest.Manifest, error) { - manifestBlob, manifestType, err := imgSrc.GetManifest(ctx, nil) - if err != nil { - return nil, fmt.Errorf("unable to get manifest blob from image : %w", err) - } - manifest, err := manifest.FromBlob(manifestBlob, manifestType) - if err != nil { - return nil, fmt.Errorf("unable to unmarshall manifest of image : %w", err) - } - return manifest, nil -} - -// getOCIImgSrcFromPath tries to "load" the OCI FBC image in the path -// for further processing. -// It supports path strings with or without the protocol (oci:) prefix -func getOCIImgSrcFromPath(ctx context.Context, path string) (types.ImageSource, error) { - if !strings.HasPrefix(path, "oci") { - path = v1alpha2.OCITransportPrefix + path - } - ociImgRef, err := alltransports.ParseImageName(path) - if err != nil { - return nil, err - } - imgsrc, err := ociImgRef.NewImageSource(ctx, nil) - if err != nil { - if err == layout.ErrMoreThanOneImage { - return nil, errors.New("multiple catalogs in the same location is not supported: https://github.com/openshift/oc-mirror/blob/main/TROUBLESHOOTING.md#error-examples") - } - return nil, fmt.Errorf("unable to get OCI Image from %s: %w", path, err) - } - return imgsrc, nil -} - -// UntarLayers simple function that untars the layer that -// has the FB configuration -func UntarLayers(gzipStream io.Reader, path string, cfgDirName string) error { - //Remove any separators in cfgDirName as received from the label - cfgDirName = strings.TrimSuffix(cfgDirName, "/") - cfgDirName = strings.TrimPrefix(cfgDirName, "/") - uncompressedStream, err := gzip.NewReader(gzipStream) - if err != nil { - return fmt.Errorf("UntarLayers: NewReader failed - %w", err) - } - - tarReader := tar.NewReader(uncompressedStream) - for { - header, err := tarReader.Next() - - if err == io.EOF { - break - } - - if err != nil { - return fmt.Errorf("UntarLayers: Next() failed: %s", err.Error()) - } - - if strings.Contains(header.Name, cfgDirName) { - switch header.Typeflag { - case tar.TypeDir: - if header.Name != "./" { - if err := os.MkdirAll(path+"/"+header.Name, 0755); err != nil { - return fmt.Errorf("UntarLayers: Mkdir() failed: %v", err) - } - } - case tar.TypeReg: - outFile, err := os.Create(path + "/" + header.Name) - if err != nil { - return fmt.Errorf("UntarLayers: Create() failed: %v", err) - } - if _, err := io.Copy(outFile, tarReader); err != nil { - return fmt.Errorf("UntarLayers: Copy() failed: %v", err) - } - outFile.Close() - - default: - // just ignore errors as we are only interested in the FB configs layer - klog.Warningf("UntarLayers: unknown type: %v in %s", header.Typeflag, header.Name) - } - } - } - return nil -} - // copyImage is used both for pulling catalog images from the remote registry // as well as pushing these catalog images to the remote registry. // It calls the underlying containers/image copy library, which looks out for registries.conf diff --git a/pkg/cli/mirror/fbc_operators_test.go b/pkg/cli/mirror/fbc_operators_test.go index aef7a6d9a..60b183d05 100644 --- a/pkg/cli/mirror/fbc_operators_test.go +++ b/pkg/cli/mirror/fbc_operators_test.go @@ -9,33 +9,38 @@ import ( "os" "path/filepath" "strings" + "sync" "testing" imagecopy "github.com/containers/image/v5/copy" "github.com/containers/image/v5/pkg/sysregistriesv2" "github.com/containers/image/v5/signature" "github.com/containers/image/v5/types" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/layout" "github.com/opencontainers/go-digest" + "github.com/openshift/library-go/pkg/image/reference" + "github.com/openshift/oc/pkg/cli/image/imagesource" + "github.com/operator-framework/operator-registry/alpha/declcfg" "github.com/otiai10/copy" + "github.com/stretchr/testify/require" + "k8s.io/cli-runtime/pkg/genericclioptions" - "github.com/openshift/library-go/pkg/image/reference" "github.com/openshift/oc-mirror/pkg/api/v1alpha2" "github.com/openshift/oc-mirror/pkg/cli" "github.com/openshift/oc-mirror/pkg/image" "github.com/openshift/oc-mirror/pkg/metadata/storage" - "github.com/openshift/oc/pkg/cli/image/imagesource" - "github.com/operator-framework/operator-registry/alpha/declcfg" - "github.com/stretchr/testify/require" - "k8s.io/cli-runtime/pkg/genericclioptions" ) const ( - testdata = "testdata/artifacts/rhop-ctlg-oci" - testdataMashed = "testdata/artifacts/rhop-ctlg-oci-mashed" - rottenManifest = "testdata/artifacts/rhop-rotten-manifest" - rottenLayer = "testdata/artifacts/rhop-rotten-layer" - rottenConfig = "testdata/artifacts/rhop-rotten-cfg" - otherLayer = "testdata/artifacts/rhop-not-catalog" + testdata = "testdata/artifacts/rhop-ctlg-oci" // this is supposed to be the "good" scenario (but its technically broken since it was hacked ... mismatched fs layers (1) and diff ids (6)) + testdataMashed = "testdata/artifacts/rhop-ctlg-oci-mashed" // (TODO: not sure what mashed means) this is supposed to be the "good" scenario + rottenManifest = "testdata/artifacts/rhop-rotten-manifest" // the manifest in the blob is broken + rottenLayer = "testdata/artifacts/rhop-rotten-layer" // this has a layer which is just text data + rottenConfig = "testdata/artifacts/rhop-rotten-cfg" // this has a broken config file + otherLayer = "testdata/artifacts/rhop-not-catalog" // this has a broken config file (TODO: only diff with rhop-rotten-cfg is blob layer... why?) + multiTestData = "testdata/manifestlist/testonly/layout" // multi architecture test case + singleTestData = "testdata/single/testonly/layout" // single architecture test case registriesConfig = "testdata/configs/registries.conf" ) @@ -53,220 +58,147 @@ func TestParse(t *testing.T) { fmt.Printf("%s - %s\n", s, rf) } -// TODO: add preparation step that saves a catalog locally before testing -// see maybe contents of pkg/image/testdata -func TestGetOCIImgSrcFromPath(t *testing.T) { - type spec struct { - desc string - inRef string - err string - } - wdir, err := os.Getwd() - if err != nil { - t.Fatal("unable to get working dir") +func TestExtractDeclarativeConfigFromImage(t *testing.T) { + + type testCase struct { + name string + layoutPath layout.Path + expectedFiles []string + assertion require.ErrorAssertionFunc } - cases := []spec{ + + tests := []testCase{ { - desc: "full path passes", - inRef: filepath.Join(wdir, testdata), - err: "", + name: "single arch", + layoutPath: layout.Path(testdata), + expectedFiles: []string{ + "aws-load-balancer-operator/catalog.json", + "node-observability-operator/catalog.json", + }, + assertion: require.NoError, }, { - desc: "relative path passes", - inRef: testdata, - err: "", + name: "multi arch", + layoutPath: layout.Path(multiTestData), + expectedFiles: []string{ + "aws-load-balancer-operator/catalog.json", + "node-observability-operator/catalog.json", + }, + assertion: require.NoError, }, + // The following two tests deal with really broken images and probably should never happen { - desc: "inexisting path should fail", - inRef: "/inexisting", - err: "unable to get OCI Image from oci:/inexisting: open /inexisting/index.json: no such file or directory", + name: "layer is not a tar.gz", + layoutPath: layout.Path(rottenLayer), + // we won't get any files back in this test case + expectedFiles: []string{}, + // NOTE: This result is slightly unexpected and requires explanation. + // go-containerregistry checks a layer to see if its actually compressed and if its not + // it will attempt to handle this gracefully and treat the layer as already uncompressed. + // It then proceeds to untar the content, but since this layer is not a tar, the tar.Next() + // function gets an unexpected EOF, and causes the PipeWriter to close. This means that when + // we attempt to read the "tar" in our code, we get an EOF, and therefore no error. + // However, the code will check to make sure the folder exists and has content in it + // and returns an error if this does not happen. + // We won't get any files either since the extraction can't complete. + assertion: require.Error, }, { - desc: "path not containing oci structure should fail", - inRef: "/tmp", - err: "unable to get OCI Image from oci:/tmp: open /tmp/index.json: no such file or directory", + name: "image has broken config file", + layoutPath: layout.Path(otherLayer), + expectedFiles: []string{}, + assertion: require.Error, }, } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - imgSrc, err := getOCIImgSrcFromPath(context.TODO(), c.inRef) - if c.err != "" { - require.EqualError(t, err, c.err) - } else { - require.NoError(t, err) - require.Equal(t, "oci", imgSrc.Reference().Transport().Name()) - imgSrc.Close() - } - - }) - } -} -func TestGetManifest(t *testing.T) { - type spec struct { - desc string - inRef string - layerCount int - err string - } - wdir, err := os.Getwd() - if err != nil { - t.Fatal("unable to get working dir") - } - cases := []spec{ - { - desc: "nominal case", - inRef: filepath.Join(wdir, testdata), - layerCount: 1, - err: "", - }, - { - desc: "index is unmarshallable fails", - inRef: filepath.Join(wdir, rottenManifest), - layerCount: 0, - err: "unable to unmarshall manifest of image : unexpected end of JSON input", - }, + // handle images... all images are expected to have the same content in these tests + handleImage := func(t *testing.T, img v1.Image, expectedFiles []string, assertion require.ErrorAssertionFunc) { + t.Helper() + tmpDir := t.TempDir() + actualDir, err := extractDeclarativeConfigFromImage(img, tmpDir) + assertion(t, err) + for _, expectedFile := range expectedFiles { + require.FileExists(t, filepath.Join(actualDir, expectedFile)) + } } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - imgSrc, err := getOCIImgSrcFromPath(context.TODO(), c.inRef) - if err != nil { - t.Fatalf("The given path is not an OCI image : %v", err) - } - defer imgSrc.Close() - manifest, err := getManifest(context.TODO(), imgSrc) - if c.err != "" { - require.EqualError(t, err, c.err) - } else { + // recursive function to handle image indexes + var handleIndex func(t *testing.T, idx v1.ImageIndex, expectedFiles []string, assertion require.ErrorAssertionFunc) + handleIndex = func(t *testing.T, idx v1.ImageIndex, expectedFiles []string, assertion require.ErrorAssertionFunc) { + t.Helper() + idxManifest, err := idx.IndexManifest() + require.NoError(t, err) + for _, descriptor := range idxManifest.Manifests { + if descriptor.MediaType.IsImage() { + img, err := idx.Image(descriptor.Digest) require.NoError(t, err) - require.Equal(t, c.layerCount, len(manifest.LayerInfos())) - } - - }) - } -} - -func TestGetConfigPathFromLabel(t *testing.T) { - type spec struct { - desc string - imagePath string - configSha string - expectedDirName string - err string - } - cases := []spec{ - { - desc: "nominal case", - imagePath: testdata, - configSha: "sha256:c7c89df4a1f53d7e619080245c4784b6f5e6232fb71e98d981b89799ae578262", - expectedDirName: "/configs", - err: "", - }, - { - desc: "sha doesnt exist fails", - imagePath: testdata, - configSha: "sha256:inexistingSha", - expectedDirName: "", - err: "unable to read the config blob inexistingSha from the oci image: open testdata/artifacts/rhop-ctlg-oci/blobs/sha256/inexistingSha: no such file or directory", - }, - { - desc: "cfg layer json incorrect fails", - imagePath: rottenConfig, - configSha: "sha256:c7c89df4a1f53d7e619080245c4784b6f5e6232fb71e98d981b89799ae578262", - expectedDirName: "", - err: "problem unmarshaling config blob in c7c89df4a1f53d7e619080245c4784b6f5e6232fb71e98d981b89799ae578262: unexpected end of JSON input", - }, - { - desc: "label doesnt exist fails", - imagePath: rottenConfig, - configSha: "sha256:c7c89df4a1f53d7e619080245c4784b6f5e6232fb71e98d981b89799ae5782ff", - expectedDirName: "", - err: "label " + configsLabel + " not found in config blob c7c89df4a1f53d7e619080245c4784b6f5e6232fb71e98d981b89799ae5782ff", - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - cfgDir, err := getConfigPathFromConfigLayer(c.imagePath, c.configSha) - if c.err != "" { - require.EqualError(t, err, c.err) - } else { + handleImage(t, img, expectedFiles, assertion) + } else if descriptor.MediaType.IsIndex() { + innerIdx, err := idx.ImageIndex(descriptor.Digest) require.NoError(t, err) - require.Equal(t, c.expectedDirName, cfgDir) + handleIndex(t, innerIdx, expectedFiles, assertion) } + } - }) - } -} - -func TestFindFBCConfig(t *testing.T) { - type spec struct { - desc string - options *MirrorOptions - err string - } - cases := []spec{ - { - desc: "nominal case", - options: &MirrorOptions{ - From: v1alpha2.OCITransportPrefix + testdata, - ToMirror: "test.registry.io", - OutputDir: testdata, - }, - err: "", - }, - { - desc: "not a FBC image fails", - options: &MirrorOptions{ - From: v1alpha2.OCITransportPrefix + testdata, - ToMirror: "test.registry.io", - OutputDir: "/tmp", - }, - err: "unable to get OCI Image from oci:/tmp: open /tmp/index.json: no such file or directory", - }, - { - desc: "corrupted manifest fails", - options: &MirrorOptions{ - From: v1alpha2.OCITransportPrefix + testdata, - ToMirror: "test.registry.io", - OutputDir: rottenManifest, - }, - err: "unable to unmarshall manifest of image : unexpected end of JSON input", - }, - { - desc: "corrupted layer fails", - options: &MirrorOptions{ - From: v1alpha2.OCITransportPrefix + testdata, - ToMirror: "test.registry.io", - OutputDir: rottenLayer, - }, - err: "UntarLayers: NewReader failed - gzip: invalid header", - }, } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - _, err := c.options.findFBCConfig(context.TODO(), c.options.OutputDir, filepath.Join(c.options.OutputDir, artifactsFolderName)) - if c.err != "" { - require.EqualError(t, err, c.err) - } else { - require.NoError(t, err) - } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + imageIndex, err := test.layoutPath.ImageIndex() + require.NoError(t, err) + handleIndex(t, imageIndex, test.expectedFiles, test.assertion) }) } } - func TestGetRelatedImages(t *testing.T) { type spec struct { desc string - configsPath string + configsPath layout.Path expectedRelatedImages []declcfg.RelatedImage err string } - tmpdir := t.TempDir() cases := []spec{ { desc: "nominal case", - configsPath: filepath.Join(testdata, blobsPath, "cac5b2f40be10e552461651655ca8f3f6ba3f65f41ecf4345efbcf1875415db6"), + configsPath: testdata, + expectedRelatedImages: []declcfg.RelatedImage{ + { + Image: "registry.redhat.io/noo/node-observability-operator-bundle-rhel8@sha256:25b8e1c8ed635364d4dcba7814ad504570b1c6053d287ab7e26c8d6a97ae3f6a", + Name: "node-observability-operator", + }, + { + Image: "registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e", + Name: "kube-rbac-proxy", + }, + { + Name: "manager", + Image: "registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19", + }, + { + Name: "agent", + Image: "registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc", + }, + { + Name: "controller", + Image: "registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece", + }, + { + Name: "registry.redhat.io/albo/aws-load-balancer-operator-bundle", + Image: "registry.redhat.io/albo/aws-load-balancer-operator-bundle@sha256:50b9402635dd4b312a86bed05dcdbda8c00120d3789ec2e9b527045100b3bdb4", + }, + { + Name: "manager", + Image: "registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d", + }, + { + Name: "kube-rbac-proxy", + Image: "registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc", + }, + }, + err: "", + }, + { + desc: "multi arch nominal case passes", + configsPath: multiTestData, expectedRelatedImages: []declcfg.RelatedImage{ { Image: "registry.redhat.io/noo/node-observability-operator-bundle-rhel8@sha256:25b8e1c8ed635364d4dcba7814ad504570b1c6053d287ab7e26c8d6a97ae3f6a", @@ -306,23 +238,45 @@ func TestGetRelatedImages(t *testing.T) { } for _, c := range cases { t.Run(c.desc, func(t *testing.T) { - //Untar the configs blob to tmpdir - stream, err := os.Open(c.configsPath) - if err != nil { - t.Fatalf("unable to open %s: %v", c.configsPath, err) + var actualDir string + // handle images... all images are expected to have the same content in these tests + // for multi arch, the actualDir gets set twice, but its the same content so it does not matter + handleImage := func(t *testing.T, img v1.Image) { + t.Helper() + tmpDir := t.TempDir() + dir, err := extractDeclarativeConfigFromImage(img, tmpDir) + require.NoError(t, err) + actualDir = dir } - err = UntarLayers(stream, tmpdir, "configs/") - if err != nil { - t.Fatalf("unable to untar %s: %v", c.configsPath, err) + // recursive function to handle image indexes + var handleIndex func(t *testing.T, idx v1.ImageIndex) + handleIndex = func(t *testing.T, idx v1.ImageIndex) { + t.Helper() + idxManifest, err := idx.IndexManifest() + require.NoError(t, err) + for _, descriptor := range idxManifest.Manifests { + if descriptor.MediaType.IsImage() { + img, err := idx.Image(descriptor.Digest) + require.NoError(t, err) + handleImage(t, img) + } else if descriptor.MediaType.IsIndex() { + innerIdx, err := idx.ImageIndex(descriptor.Digest) + require.NoError(t, err) + handleIndex(t, innerIdx) + } + } } - directory := filepath.Join(tmpdir, "configs") - cfg, err := declcfg.LoadFS(os.DirFS(directory)) + imageIndex, err := c.configsPath.ImageIndex() + require.NoError(t, err) + handleIndex(t, imageIndex) + cfg, err := declcfg.LoadFS(os.DirFS(actualDir)) if err != nil { t.Fatalf("unable to load the declarative config %s", err.Error()) } relatedImages, err := getRelatedImages(*cfg) + if c.err != "" { require.EqualError(t, err, c.err) } else { @@ -470,68 +424,6 @@ func TestGetISConfig(t *testing.T) { }) } -func TestUntarLayers(t *testing.T) { - type spec struct { - desc string - configsPath string - expectedSubFolders []string - err string - } - cases := []spec{ - { - desc: "nominal case", - configsPath: filepath.Join(testdata, blobsPath, "cac5b2f40be10e552461651655ca8f3f6ba3f65f41ecf4345efbcf1875415db6"), - expectedSubFolders: []string{"node-observability-operator", "aws-load-balancer-operator"}, - err: "", - }, - { - desc: "layer is not a tar.gz fails", - configsPath: filepath.Join(rottenLayer, blobsPath, "1a6ae3d35ced1c7654b3bf1a66b8a513d2ee7f497728e0c5c74841807c4b8e77"), - expectedSubFolders: nil, - err: "UntarLayers: NewReader failed - gzip: invalid header", - }, - { - desc: "layer doesnt contain configs folder", - configsPath: filepath.Join(otherLayer, blobsPath, "cac5b2f40be10e552461651655ca8f3f6ba3f65f41ecf4345efbcf1875415db6"), - expectedSubFolders: []string{}, - err: "", - }, - } - for _, c := range cases { - tmpdir := t.TempDir() - t.Run(c.desc, func(t *testing.T) { - //Untar the configs blob to tmpdir - stream, err := os.Open(c.configsPath) - if err != nil { - t.Fatalf("unable to open %s: %v", c.configsPath, err) - } - err = UntarLayers(stream, tmpdir, "configs/") - if c.err != "" { - require.EqualError(t, err, c.err) - } else { - require.NoError(t, err) - f, err := os.Open(filepath.Join(tmpdir, "configs")) - if err != nil && len(c.expectedSubFolders) == 0 { - //here the filter caught 0 configs folder, so the error is normal - return - } else if err != nil && len(c.expectedSubFolders) > 0 { - t.Errorf("unable to open the untarred folder: %v", err) - t.Fail() - } - subfolders, err := f.Readdir(0) - if err != nil { - t.Errorf("unable to read untarred folder contents: %v", err) - t.Fail() - } - require.Equal(t, len(c.expectedSubFolders), len(subfolders)) - for _, sf := range subfolders { - require.Contains(t, c.expectedSubFolders, sf.Name()) - } - } - }) - } -} - func TestFirstAvailableMirror(t *testing.T) { type spec struct { desc string @@ -820,7 +712,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "no targetName, targetTag", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), }, destReg: "localhost:5000", namespace: "disconnected_ocp", @@ -830,7 +722,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "with targetName, no targetTag", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), TargetName: "rhopi", }, destReg: "localhost:5000", @@ -841,7 +733,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "with targetTag and no targetName", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), TargetTag: "v12", }, destReg: "localhost:5000", @@ -852,7 +744,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "with targetTag and targetName", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), TargetTag: "v12", TargetName: "rhopi", }, @@ -864,7 +756,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "with targetCatalog", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), TargetTag: "v12", TargetCatalog: "chosen_ns/rhopi", }, @@ -876,7 +768,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "destReg empty", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), }, destReg: "", namespace: "disconnected_ocp", @@ -886,7 +778,7 @@ func TestPrepareDestCatalogRef(t *testing.T) { { desc: "namespace empty", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), }, destReg: "localhost:5000", namespace: "", @@ -920,9 +812,9 @@ func TestAddCatalogToMapping(t *testing.T) { { desc: "source FBC digest provided", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), }, - digest: digest.FromString("just for testing"), + digest: "sha256:c7c89df4a1f53d7e619080245c4784b6f5e6232fb71e98d981b89799ae578262", destRef: "docker://localhost:5000/disconnected_ocp/redhat-operator-index:4.12", expMapping: image.TypedImageMapping{ @@ -934,7 +826,7 @@ func TestAddCatalogToMapping(t *testing.T) { Namespace: "artifacts", Name: "rhop-ctlg-oci", Tag: "", - ID: digest.FromString("just for testing").String(), + ID: "sha256:3986c6e039692ada9b5fa79ce51ce49bf6b24bc3af91d96e6c9d3d72f8077401", }, OCIFBCPath: "oci://testdata/artifacts/rhop-ctlg-oci", }, @@ -948,7 +840,7 @@ func TestAddCatalogToMapping(t *testing.T) { Namespace: "disconnected_ocp", Name: "redhat-operator-index", Tag: "4.12", - ID: digest.FromString("just for testing").String(), + ID: "sha256:3986c6e039692ada9b5fa79ce51ce49bf6b24bc3af91d96e6c9d3d72f8077401", }, OCIFBCPath: "", }, @@ -961,7 +853,7 @@ func TestAddCatalogToMapping(t *testing.T) { { desc: "source FBC, digest not provided", operator: v1alpha2.Operator{ - Catalog: "oci://" + testdata, + Catalog: fmt.Sprintf("%s//%s", v1alpha2.OCITransportPrefix, testdata), }, digest: "", destRef: "docker://localhost:5000/disconnected_ocp/redhat-operator-index:v4.12", @@ -1199,8 +1091,16 @@ func TestAddRelatedImageToMapping(t *testing.T) { for _, c := range cases { t.Run(c.desc, func(t *testing.T) { mapping := image.TypedImageMapping{} - err := c.options.addRelatedImageToMapping(context.TODO(), mapping, c.img, c.destReg, c.namespace) - + syncMap := sync.Map{} + err := c.options.addRelatedImageToMapping(context.TODO(), &syncMap, c.img, c.destReg, c.namespace) + // convert to a more easily testable map type + syncMap.Range(func(key, value any) bool { + source := key.(image.TypedImage) + destination := value.(image.TypedImage) + mapping[source] = destination + // always continue iteration + return true + }) if c.expErr != "" { require.EqualError(t, err, c.expErr) } else { diff --git a/pkg/cli/mirror/mirror.go b/pkg/cli/mirror/mirror.go index 8d27422a0..72ea82fb0 100644 --- a/pkg/cli/mirror/mirror.go +++ b/pkg/cli/mirror/mirror.go @@ -81,7 +81,9 @@ const ( ) func NewMirrorCmd() *cobra.Command { - o := MirrorOptions{} + o := MirrorOptions{ + operatorCatalogToFullArtifactPath: map[string]string{}, + } o.RootOptions = &cli.RootOptions{ IOStreams: genericclioptions.IOStreams{ In: os.Stdin, @@ -166,7 +168,8 @@ func (o *MirrorOptions) Complete(cmd *cobra.Command, args []string) error { return err } o.ToMirror = mirror.Ref.Registry - o.UserNamespace = mirror.Ref.AsRepository().RepositoryName() + // get the / portion of the docker reference only + o.UserNamespace = mirror.Ref.RepositoryName() err = checkDockerReference(mirror, o.MaxNestedPaths) if err != nil { return err @@ -302,7 +305,7 @@ func (o *MirrorOptions) Run(cmd *cobra.Command, f kcmdutil.Factory) (err error) cleanup := func() error { if !o.SkipCleanup { - os.RemoveAll("olm_artifacts") + os.RemoveAll(artifactsFolderName) return os.RemoveAll(filepath.Join(o.Dir, config.SourceDir)) } return nil diff --git a/pkg/cli/mirror/operator.go b/pkg/cli/mirror/operator.go index a742c6b8f..58154cfc5 100644 --- a/pkg/cli/mirror/operator.go +++ b/pkg/cli/mirror/operator.go @@ -9,6 +9,7 @@ import ( "os" "path/filepath" "strings" + "sync" "time" "github.com/containerd/containerd/errdefs" @@ -27,6 +28,7 @@ import ( "github.com/operator-framework/operator-registry/pkg/image/containerdregistry" "github.com/otiai10/copy" "github.com/sirupsen/logrus" + "golang.org/x/sync/errgroup" utilerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/yaml" "k8s.io/klog/v2" @@ -58,13 +60,47 @@ func NewOperatorOptions(mo *MirrorOptions) *OperatorOptions { return opts } -// PlanFull plans a mirror for each catalog image in its entirety -func (o *OperatorOptions) PlanFull(ctx context.Context, cfg v1alpha2.ImageSetConfiguration) (image.TypedImageMapping, error) { +/* +PlanFull plans a mirror for each catalog image in its entirety + +# Arguments + +• ctx: A cancellation context + +• cfg: An ImageSetConfiguration that should be processed + +# Returns + +• image.TypedImageMapping: Any src->dest mappings found during planning. Will be nil if an error occurs, non-nil otherwise. + +• error: non-nil if an error occurs, nil otherwise +*/ +func (o *OperatorOptions) PlanFull( + ctx context.Context, + cfg v1alpha2.ImageSetConfiguration, +) (image.TypedImageMapping, error) { return o.run(ctx, cfg, o.renderDCFull) } -// PlanDiff plans only the diff between each old and new catalog image pair +/* +PlanDiff plans only the diff between each old and new catalog image pair + +# Arguments + +• ctx: A cancellation context + +• cfg: An ImageSetConfiguration that should be processed + +• lastRun: The mirror results of the last run + +# Returns + +• image.TypedImageMapping: Any src->dest mappings found during planning. Will be nil if an error occurs, non-nil otherwise. + +• error: non-nil if an error occurs, nil otherwise +*/ func (o *OperatorOptions) PlanDiff(ctx context.Context, cfg v1alpha2.ImageSetConfiguration, lastRun v1alpha2.PastMirror) (image.TypedImageMapping, error) { + // Wrapper renderDCDiff so it satisfies the renderDCFunc function signature. f := func(ctx context.Context, reg *containerdregistry.Registry, ctlg v1alpha2.Operator) (*declcfg.DeclarativeConfig, v1alpha2.IncludeConfig, error) { return o.renderDCDiff(ctx, reg, ctlg, lastRun) } @@ -82,9 +118,33 @@ func (o *OperatorOptions) complete() { } } -type renderDCFunc func(context.Context, *containerdregistry.Registry, v1alpha2.Operator) (*declcfg.DeclarativeConfig, v1alpha2.IncludeConfig, error) +/* +renderDCFunc is a function signature for rendering declarative configurations for a catalog. +Currently renderDCFull and renderDCDiff implement this function signature. + +# Arguments + +• context.Context: the cancellation context + +• *containerdregistry.Registry: a containerd registry + +• v1alpha2.Operator: operator metadata that should be processed -func (o *OperatorOptions) run(ctx context.Context, cfg v1alpha2.ImageSetConfiguration, renderDC renderDCFunc) (image.TypedImageMapping, error) { +# Returns + +• error: non-nil if an error occurs, nil otherwise +*/ +type renderDCFunc func( + context.Context, + *containerdregistry.Registry, + v1alpha2.Operator, +) (*declcfg.DeclarativeConfig, v1alpha2.IncludeConfig, error) + +func (o *OperatorOptions) run( + ctx context.Context, + cfg v1alpha2.ImageSetConfiguration, + renderDC renderDCFunc, +) (image.TypedImageMapping, error) { o.complete() cleanup, err := o.mktempDir() @@ -167,7 +227,12 @@ func (o *OperatorOptions) createRegistry() (*containerdregistry.Registry, error) } // renderDCFull renders data in ctlg into a declarative config for o.Full(). -func (o *OperatorOptions) renderDCFull(ctx context.Context, reg *containerdregistry.Registry, ctlg v1alpha2.Operator) (dc *declcfg.DeclarativeConfig, ic v1alpha2.IncludeConfig, err error) { +// Satisfies the renderDCFunc function signature. +func (o *OperatorOptions) renderDCFull( + ctx context.Context, + reg *containerdregistry.Registry, + ctlg v1alpha2.Operator, +) (dc *declcfg.DeclarativeConfig, ic v1alpha2.IncludeConfig, err error) { hasInclude := len(ctlg.IncludeConfig.Packages) != 0 // Render the full catalog if neither HeadsOnly or IncludeConfig are specified. @@ -177,8 +242,9 @@ func (o *OperatorOptions) renderDCFull(ctx context.Context, reg *containerdregis ctlgRef := ctlg.Catalog //applies for all docker-v2 remote catalogs if ctlg.IsFBCOCI() { // initialize path where we assume the catalog config dir is /olm_artifacts// - ctlgRef, err = o.getOperatorCatalogRef(ctx, ctlg.Catalog) - if err != nil { + var ok bool + if ctlgRef, ok = o.operatorCatalogToFullArtifactPath[ctlg.Catalog]; !ok { + err = fmt.Errorf("unable to obtain artifact path for %s while performing full render", ctlg.Catalog) return dc, ic, err } } @@ -232,8 +298,13 @@ func (o *OperatorOptions) renderDCFull(ctx context.Context, reg *containerdregis // renderDCDiff renders data in ctlg into a declarative config for o.PlanDiff(). // This produces the declarative config that will be used to determine -// differential images -func (o *OperatorOptions) renderDCDiff(ctx context.Context, reg *containerdregistry.Registry, ctlg v1alpha2.Operator, lastRun v1alpha2.PastMirror) (dc *declcfg.DeclarativeConfig, ic v1alpha2.IncludeConfig, err error) { +// differential images. +func (o *OperatorOptions) renderDCDiff( + ctx context.Context, + reg *containerdregistry.Registry, + ctlg v1alpha2.Operator, + lastRun v1alpha2.PastMirror, +) (dc *declcfg.DeclarativeConfig, ic v1alpha2.IncludeConfig, err error) { prevCatalog := make(map[string]v1alpha2.OperatorMetadata, len(lastRun.Operators)) for _, pastCtlg := range lastRun.Operators { prevCatalog[pastCtlg.Catalog] = pastCtlg @@ -262,8 +333,9 @@ func (o *OperatorOptions) renderDCDiff(ctx context.Context, reg *containerdregis ctlgRef := ctlg.Catalog //applies for all docker-v2 remote catalogs if ctlg.IsFBCOCI() { - ctlgRef, err = o.getOperatorCatalogRef(ctx, ctlg.Catalog) - if err != nil { + var ok bool + if ctlgRef, ok = o.operatorCatalogToFullArtifactPath[ctlg.Catalog]; !ok { + err = fmt.Errorf("unable to obtain artifact path for %s while performing diff render", ctlg.Catalog) return dc, ic, err } } @@ -365,6 +437,27 @@ func (o *OperatorOptions) verifyDC(dic diff.DiffIncludeConfig, dc *declcfg.Decla return nil } +/* +plan determines the source -> destination mapping for images associated with the provided catalog + +# Arguments + +• ctx: A cancellation context + +• dc: the declarative config to use during processing + +• ic: the include config associated with the dc argument + +• ctlgRef: this is the source catalog reference + +• targetCtlg: this is the target catalog reference + +# Return + +• image.TypedImageMapping: the source -> destination image mapping for images found during planning + +• error: non-nil if an error occurs, nil otherwise +*/ func (o *OperatorOptions) plan(ctx context.Context, dc *declcfg.DeclarativeConfig, ic v1alpha2.IncludeConfig, ctlgRef, targetCtlg image.TypedImageReference) (image.TypedImageMapping, error) { o.Logger.Debugf("Mirroring catalog %q bundle and related images", ctlgRef.Ref.Exact()) @@ -431,16 +524,38 @@ func (o *OperatorOptions) plan(ctx context.Context, dc *declcfg.DeclarativeConfi // place related images into the workspace - aka mirrorToDisk // TODO this should probably be done only if artifacts have not been copied - result := image.TypedImageMapping{} + var syncMapResult sync.Map + start := time.Now() + g, ctx := errgroup.WithContext(ctx) // create mappings for the related images that will moved from the workspace to the final destination for _, i := range relatedImages { - // intentionally removed the usernamespace from the call, because mirror.go is going to add it back!! - err := o.addRelatedImageToMapping(ctx, result, i, o.ToMirror, "") - if err != nil { - return nil, err - } - + // avoid closure problems by making a copy of i + copyofI := i + g.Go(func() error { + // intentionally removed the usernamespace from the call, because mirror.go is going to add it back!! + err := o.addRelatedImageToMapping(ctx, &syncMapResult, copyofI, o.ToMirror, "") + if err != nil { + return err + } + return nil + }) + } + // if error occurs in one of the go routines, get the first error and bail out + if err := g.Wait(); err != nil { + return nil, err } + duration := time.Since(start) + klog.Infof("%d related images processed in %s", len(relatedImages), duration) + + result := image.TypedImageMapping{} + syncMapResult.Range(func(key, value any) bool { + source := key.(image.TypedImage) + destination := value.(image.TypedImage) + result[source] = destination + // always continue iteration + return true + }) + if err := o.writeMappingFile(mappingFile, result); err != nil { return nil, err } @@ -472,16 +587,31 @@ func (o *OperatorOptions) plan(ctx context.Context, dc *declcfg.DeclarativeConfi return nil, err } } else { + // ctlgDir is the result of converting targetCtlg.Ref to example: foo/bar/baz/image/sha256:XXXX ctlgDir, err := operator.GenerateCatalogDir(targetCtlg.Ref) if err != nil { return nil, err } + // layoutDir looks like /src/catalogs//layout + // this will be the destination of the copy action that follows layoutDir := filepath.Join(o.Dir, config.SourceDir, config.CatalogsDir, ctlgDir, config.LayoutsDir) if err := os.MkdirAll(layoutDir, os.ModePerm); err != nil { return nil, fmt.Errorf("error catalog layout dir: %v", err) } - if err := copy.Copy(v1alpha2.TrimProtocol(ctlgRef.OCIFBCPath), layoutDir); err != nil { - return nil, fmt.Errorf("error copying oci fbc catalog to layout directory: %v", err) + // obtain the source directory for the OCI content + ociSourcePath := v1alpha2.TrimProtocol(ctlgRef.OCIFBCPath) + + // Now copy the individual components of the source OCI source to its layout dir destination. + // This is done to ensure that files/folders that are not part of the OCI layout specification + // are not copied. + if err := copyOCILayoutFileOrFolder(ociSourcePath, layoutDir, "oci-layout"); err != nil { + return nil, err + } + if err := copyOCILayoutFileOrFolder(ociSourcePath, layoutDir, "index.json"); err != nil { + return nil, err + } + if err := copyOCILayoutFileOrFolder(ociSourcePath, layoutDir, "blobs"); err != nil { + return nil, err } } @@ -501,8 +631,43 @@ func (o *OperatorOptions) plan(ctx context.Context, dc *declcfg.DeclarativeConfi return mappings, validateMapping(*dc, mappings) } -// validateMapping will search for bundle and related images in mapping -// and log a warning if an image does not exist and will not be mirrored +/* +copyOCILayoutFileOrFolder will copy a file or folder that belongs to a oci layout + +# Arguments + +• sourcePath: the source directory + +• destinationPath: the destination directory + +• fileOrDir: the file or directory within the source that will be copied to the destination + +# Returns + +• error: non nil if file/folder copy failed, nil otherwise +*/ +func copyOCILayoutFileOrFolder(sourcePath, destinationPath, fileOrDir string) error { + if err := copy.Copy(filepath.Join(sourcePath, fileOrDir), filepath.Join(destinationPath, fileOrDir)); err != nil { + return fmt.Errorf("error copying oci fbc catalog to layout directory: %v", err) + } + return nil +} + +/* +validateMapping will search for bundle and related images in mapping +and log a warning if an image does not exist and will not be mirrored. + +# Arguments + +• dc: the catalog content that contains bundle and related images + +• mapping: the source/destination mapping to search through looking for a match based on the catalog content + +# Returns + +• error: this should only produce an error if the bundle or related images in the catalog could +not be parsed +*/ func validateMapping(dc declcfg.DeclarativeConfig, mapping image.TypedImageMapping) error { var errs []error validateFunc := func(img string) error { @@ -585,14 +750,32 @@ func (o *OperatorOptions) pinImages(ctx context.Context, dc *declcfg.Declarative return utilerrors.NewAggregate(errs) } +/* +writeLayout creates OCI layout on the file system by pulling the image from the ctlgRef argument + +# Arguments + +• ctx: A cancellation context + +• ctlgRef: this is the source catalog reference + +• targetCtlg: this is the target catalog reference + +# Return + +• error: non-nil if an error occurs, nil otherwise +*/ func (o *OperatorOptions) writeLayout(ctx context.Context, ctlgRef, targetCtlg imgreference.DockerImageReference) error { // Write catalog OCI layout file to src so it is included in the archive // at a path unique to the image. + + // ctlgDir is the result of converting targetCtlg to example: foo.io/bar/baz/image/sha256:XXXX ctlgDir, err := operator.GenerateCatalogDir(targetCtlg) if err != nil { return err } + // layoutDir looks like /src/catalogs//layout layoutDir := filepath.Join(o.Dir, config.SourceDir, config.CatalogsDir, ctlgDir, config.LayoutsDir) if err := os.MkdirAll(layoutDir, os.ModePerm); err != nil { return fmt.Errorf("error catalog layout dir: %v", err) @@ -618,8 +801,18 @@ func (o *OperatorOptions) writeLayout(ctx context.Context, ctlgRef, targetCtlg i if err != nil { return err } - // Default to amd64 architecture with no multi-arch image - if err := layoutPath.AppendImage(img, layout.WithPlatform(v1.Platform{OS: "linux", Architecture: "amd64"})); err != nil { + // try to get the config file... does it have os/arch values? + configFile, err := img.ConfigFile() + if err != nil || configFile == nil || (configFile.Architecture == "" && configFile.OS == "") { + o.Logger.Debugf("could not determine platform for catalog image %s, using linux/amd64 instead", ref.Name()) + // Default to amd64 architecture with no multi-arch image since we can't know for sure what this image is + if err := layoutPath.AppendImage(img, layout.WithPlatform(v1.Platform{OS: "linux", Architecture: "amd64"})); err != nil { + return err + } + return nil + } + // set the correct platform while appending the image + if err := layoutPath.AppendImage(img, layout.WithPlatform(v1.Platform{OS: configFile.OS, Architecture: configFile.Architecture, Variant: configFile.Variant})); err != nil { return err } @@ -636,20 +829,42 @@ func (o *OperatorOptions) writeLayout(ctx context.Context, ctlgRef, targetCtlg i return nil } -// writeConfigs will write the declarative and include configuration to disk in a directory generated by the catalog name. +/* +writeConfigs will write the declarative and include configuration to disk in a directory generated by the catalog name. + +# Arguments + +• dc: the declarative config to use during processing + +• ic: the include config associated with the dc argument + +• targetCtlg: this is the target catalog reference + +# Return + +• string: the index directory + +• error: non-nil if an error occurs, nil otherwise +*/ func (o *OperatorOptions) writeConfigs(dc *declcfg.DeclarativeConfig, ic v1alpha2.IncludeConfig, targetCtlg imgreference.DockerImageReference) (string, error) { // Write catalog declarative config file to src so it is included in the archive // at a path unique to the image. + + // ctlgDir is the result of converting targetCtlg to example: foo.io/bar/baz/image/sha256:XXXX ctlgDir, err := operator.GenerateCatalogDir(targetCtlg) if err != nil { return "", err } + + // catalogBasePath looks like /src/catalogs/ catalogBasePath := filepath.Join(o.Dir, config.SourceDir, config.CatalogsDir, ctlgDir) + // indexDir looks like /src/catalogs//index indexDir := filepath.Join(catalogBasePath, config.IndexDir) if err := os.MkdirAll(indexDir, os.ModePerm); err != nil { return "", fmt.Errorf("error creating diff index dir: %v", err) } + // catalogIndexPath looks like /src/catalogs//index/index.json catalogIndexPath := filepath.Join(indexDir, "index.json") o.Logger.Debugf("writing target catalog %q diff to %s", targetCtlg.Exact(), catalogIndexPath) @@ -659,6 +874,7 @@ func (o *OperatorOptions) writeConfigs(dc *declcfg.DeclarativeConfig, ic v1alpha return "", fmt.Errorf("error creating diff index file: %v", err) } + // includeConfigPath looks like /src/catalogs//include-config.gob includeConfigPath := filepath.Join(catalogBasePath, config.IncludeConfigFile) o.Logger.Debugf("writing target catalog %q include config to %s", targetCtlg.Exact(), includeConfigPath) @@ -804,19 +1020,3 @@ func (o *OperatorOptions) checkValidationErr(err error) error { fmt.Fprintln(o.ErrOut, validationMsg) return err } - -func (o OperatorOptions) getOperatorCatalogRef(ctx context.Context, ref string) (string, error) { - _, _, repo, _, _ := v1alpha2.ParseImageReference(ref) - artifactsPath := artifactsFolderName - operatorCatalog := v1alpha2.TrimProtocol(ref) - // check for the valid config label to use - configsLabel, err := o.GetCatalogConfigPath(ctx, operatorCatalog) - if err != nil { - return "", fmt.Errorf("unable to retrieve configs layer for image %s:\n%v\nMake sure this catalog is in OCI format", ref, err) - } - // initialize path starting with /olm_artifacts/ - catalogContentsDir := filepath.Join(artifactsPath, repo) - // initialize path where we assume the catalog config dir is /olm_artifacts// - ctlgRef := filepath.Join(catalogContentsDir, configsLabel) - return ctlgRef, nil -} diff --git a/pkg/cli/mirror/options.go b/pkg/cli/mirror/options.go index 4298289bc..a60cc2629 100644 --- a/pkg/cli/mirror/options.go +++ b/pkg/cli/mirror/options.go @@ -14,35 +14,36 @@ import ( type MirrorOptions struct { *cli.RootOptions - OutputDir string - ConfigPath string - SkipImagePin bool - ManifestsOnly bool - From string - ToMirror string - UserNamespace string - DryRun bool - SourceSkipTLS bool - DestSkipTLS bool - SourcePlainHTTP bool - DestPlainHTTP bool - SkipVerification bool - SkipCleanup bool - SkipMissing bool - SkipMetadataCheck bool - SkipPruning bool - ContinueOnError bool - IgnoreHistory bool - MaxPerRegistry int - IncludeLocalOCICatalogs bool - OCIRegistriesConfig string - OCIInsecureSignaturePolicy bool + OutputDir string // directory path, whose value is dependent on how oc mirror was invoked + ConfigPath string // Path to imageset configuration file + SkipImagePin bool // Do not replace image tags with digest pins in operator catalogs + ManifestsOnly bool // Generate manifests and do not mirror + From string // Path to an input file (e.g. archived imageset) + ToMirror string // Final destination for the mirror operation + UserNamespace string // The / portion of a docker reference only + DryRun bool // Print actions without mirroring images + SourceSkipTLS bool // Disable TLS validation for source registry + DestSkipTLS bool // Disable TLS validation for destination registry + SourcePlainHTTP bool // Use plain HTTP for source registry + DestPlainHTTP bool // Use plain HTTP for destination registry + SkipVerification bool // Skip verifying the integrity of the retrieved content. + SkipCleanup bool // Skip removal of artifact directories + SkipMissing bool // If an input image is not found, skip them. + SkipMetadataCheck bool // Skip metadata when publishing an imageset + SkipPruning bool // If set, will disable pruning globally + ContinueOnError bool // If an error occurs, keep going and attempt to complete operations if possible + IgnoreHistory bool // Ignore past mirrors when downloading images and packing layers + MaxPerRegistry int // Number of concurrent requests allowed per registry + IncludeLocalOCICatalogs bool // If set, enables including local OCI-formatted catalogs (prefix oci://) in the list of operator catalogs defined in ImageSetConfig, so that these local catalogs are mirrored from the disk directly + OCIRegistriesConfig string // Registries config file location (used only with --use-oci-feature flag) + OCIInsecureSignaturePolicy bool // If set, OCI catalog push will not try to push signatures MaxNestedPaths int // cancelCh is a channel listening for command cancellations - cancelCh <-chan struct{} - once sync.Once - continuedOnError bool - remoteRegFuncs RemoteRegFuncs + cancelCh <-chan struct{} + once sync.Once + continuedOnError bool + remoteRegFuncs RemoteRegFuncs + operatorCatalogToFullArtifactPath map[string]string // stores temporary paths to declarative config directory key: OCI URI (e.g. oci://foo which originates with v1alpha2.Operator.Catalog) value: /olm_artifacts// } func (o *MirrorOptions) BindFlags(fs *pflag.FlagSet) { diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/README.md b/pkg/cli/mirror/testdata/manifestlist/hello/README.md new file mode 100644 index 000000000..a8f8f5b0e --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/README.md @@ -0,0 +1,3 @@ +# NOTICE + +This hello OCI layout does NOT contain a catalog image. It should only be used for manifest list testing. \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/2db29710123e3e53a794f2694094b9b4338aa9ee5c40b930cb8063a1be392c54 b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/2db29710123e3e53a794f2694094b9b4338aa9ee5c40b930cb8063a1be392c54 new file mode 100644 index 000000000..d3283db35 Binary files /dev/null and b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/2db29710123e3e53a794f2694094b9b4338aa9ee5c40b930cb8063a1be392c54 differ diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/abc70fcc95b2f52b325d69cc5c259dd9babb40a9df152e88b286fada1d3248bd b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/abc70fcc95b2f52b325d69cc5c259dd9babb40a9df152e88b286fada1d3248bd new file mode 100644 index 000000000..4401b5648 Binary files /dev/null and b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/abc70fcc95b2f52b325d69cc5c259dd9babb40a9df152e88b286fada1d3248bd differ diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/c7b6944911848ce39b44ed660d95fb54d69bbd531de724c7ce6fc9f743c0b861 b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/c7b6944911848ce39b44ed660d95fb54d69bbd531de724c7ce6fc9f743c0b861 new file mode 100644 index 000000000..b7cc82d14 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/c7b6944911848ce39b44ed660d95fb54d69bbd531de724c7ce6fc9f743c0b861 @@ -0,0 +1,16 @@ +{ + "schemaVersion": 2, + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "size": 1469, + "digest": "sha256:df5477cea5582b0ae6a31de2d1c9bbacb506091f42a3b0fe77a209006f409fd8" + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "size": 3276, + "digest": "sha256:abc70fcc95b2f52b325d69cc5c259dd9babb40a9df152e88b286fada1d3248bd" + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/d0c9de6b9869c144aca831898c562d01169b740e50a73b8893cdd05ab94c64b7 b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/d0c9de6b9869c144aca831898c562d01169b740e50a73b8893cdd05ab94c64b7 new file mode 100644 index 000000000..3e7125664 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/d0c9de6b9869c144aca831898c562d01169b740e50a73b8893cdd05ab94c64b7 @@ -0,0 +1,24 @@ +{ + "schemaVersion": 2, + "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "size": 525, + "digest": "sha256:f54a58bc1aac5ea1a25d796ae155dc228b3f0e11d046ae276b39c4bf2f13d8c4", + "platform": { + "architecture": "amd64", + "os": "linux" + } + }, + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "size": 525, + "digest": "sha256:c7b6944911848ce39b44ed660d95fb54d69bbd531de724c7ce6fc9f743c0b861", + "platform": { + "architecture": "s390x", + "os": "linux" + } + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/df5477cea5582b0ae6a31de2d1c9bbacb506091f42a3b0fe77a209006f409fd8 b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/df5477cea5582b0ae6a31de2d1c9bbacb506091f42a3b0fe77a209006f409fd8 new file mode 100644 index 000000000..227d37bbc --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/df5477cea5582b0ae6a31de2d1c9bbacb506091f42a3b0fe77a209006f409fd8 @@ -0,0 +1 @@ +{"architecture":"s390x","config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Cmd":["/hello"],"Image":"sha256:214c20be6ceaa7b24f8fa966550831a7f608c00cbb3408ac8f6171a222cacb14","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"container":"f7ac7ed191763ba1d368b5b35d668adf6aad7ffabdea048634935eb900450c2e","container_config":{"Hostname":"f7ac7ed19176","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Cmd":["/bin/sh","-c","#(nop) ","CMD [\"/hello\"]"],"Image":"sha256:214c20be6ceaa7b24f8fa966550831a7f608c00cbb3408ac8f6171a222cacb14","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":{}},"created":"2021-09-23T22:39:54.089350115Z","docker_version":"20.10.7","history":[{"created":"2021-09-23T22:39:53.962038173Z","created_by":"/bin/sh -c #(nop) COPY file:600d8ab1c71de7b59c96ed558afbed478d81ebf3ef7517c4c4f3757cc136475f in / "},{"created":"2021-09-23T22:39:54.089350115Z","created_by":"/bin/sh -c #(nop) CMD [\"/hello\"]","empty_layer":true}],"os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:9731f28beed099abd643f17ffb5aceea4cd916affaacc79261a98b9ddddd4a36"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/f54a58bc1aac5ea1a25d796ae155dc228b3f0e11d046ae276b39c4bf2f13d8c4 b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/f54a58bc1aac5ea1a25d796ae155dc228b3f0e11d046ae276b39c4bf2f13d8c4 new file mode 100644 index 000000000..10e6c849c --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/f54a58bc1aac5ea1a25d796ae155dc228b3f0e11d046ae276b39c4bf2f13d8c4 @@ -0,0 +1,16 @@ +{ + "schemaVersion": 2, + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "size": 1469, + "digest": "sha256:feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412" + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "size": 2479, + "digest": "sha256:2db29710123e3e53a794f2694094b9b4338aa9ee5c40b930cb8063a1be392c54" + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412 b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412 new file mode 100644 index 000000000..b85269e0f --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/blobs/sha256/feb5d9fea6a5e9606aa995e879d862b825965ba48de054caab5ef356dc6b3412 @@ -0,0 +1 @@ +{"architecture":"amd64","config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Cmd":["/hello"],"Image":"sha256:b9935d4e8431fb1a7f0989304ec86b3329a99a25f5efdc7f09f3f8c41434ca6d","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"container":"8746661ca3c2f215da94e6d3f7dfdcafaff5ec0b21c9aff6af3dc379a82fbc72","container_config":{"Hostname":"8746661ca3c2","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Cmd":["/bin/sh","-c","#(nop) ","CMD [\"/hello\"]"],"Image":"sha256:b9935d4e8431fb1a7f0989304ec86b3329a99a25f5efdc7f09f3f8c41434ca6d","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":{}},"created":"2021-09-23T23:47:57.442225064Z","docker_version":"20.10.7","history":[{"created":"2021-09-23T23:47:57.098990892Z","created_by":"/bin/sh -c #(nop) COPY file:50563a97010fd7ce1ceebd1fa4f4891ac3decdf428333fb2683696f4358af6c2 in / "},{"created":"2021-09-23T23:47:57.442225064Z","created_by":"/bin/sh -c #(nop) CMD [\"/hello\"]","empty_layer":true}],"os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:e07ee1baac5fae6a26f30cabfe54a36d3402f96afda318fe0a96cec4ca393359"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/index.json b/pkg/cli/mirror/testdata/manifestlist/hello/index.json new file mode 100755 index 000000000..a495204da --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/index.json @@ -0,0 +1,10 @@ +{ + "schemaVersion": 2, + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", + "size": 743, + "digest": "sha256:d0c9de6b9869c144aca831898c562d01169b740e50a73b8893cdd05ab94c64b7" + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/hello/oci-layout b/pkg/cli/mirror/testdata/manifestlist/hello/oci-layout new file mode 100755 index 000000000..224a86981 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/hello/oci-layout @@ -0,0 +1,3 @@ +{ + "imageLayoutVersion": "1.0.0" +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/README.md b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/README.md new file mode 100644 index 000000000..a7f7305df --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/README.md @@ -0,0 +1,4 @@ +# NOTICE + +This is a direct copy of the ./testonly layout, but manually modified to place the manifest +list directly within the index.json. This is probably uncommon, but still technically valid. \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac new file mode 100644 index 000000000..6dd57b335 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac @@ -0,0 +1,16 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "schemaVersion": 2, + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "digest": "sha256:9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66", + "size": 1168 + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "digest": "sha256:da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e", + "size": 78717 + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29 b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29 new file mode 100644 index 000000000..b93908c93 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29 @@ -0,0 +1 @@ +{"architecture":"ppc64le","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-10T20:56:22.923857404Z","history":[{"created":"2023-03-10T20:56:22.923857404Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"moby.buildkit.buildinfo.v1":"eyJmcm9udGVuZCI6ImRvY2tlcmZpbGUudjAifQ==","os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:49a0b15145b6415d136ba894bd24d77efc211c25e5d46c81ee5669920af19658"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790 b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790 new file mode 100644 index 000000000..2e14dd082 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790 @@ -0,0 +1,16 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "schemaVersion": 2, + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "digest": "sha256:242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29", + "size": 1170 + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "digest": "sha256:da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e", + "size": 78717 + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58 b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58 new file mode 100644 index 000000000..329f4809c --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58 @@ -0,0 +1,16 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "schemaVersion": 2, + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "digest": "sha256:d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a", + "size": 1168 + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "digest": "sha256:da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e", + "size": 78717 + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66 b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66 new file mode 100644 index 000000000..756c209b8 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66 @@ -0,0 +1 @@ +{"architecture":"s390x","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-10T20:56:22.923857404Z","history":[{"created":"2023-03-10T20:56:22.923857404Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"moby.buildkit.buildinfo.v1":"eyJmcm9udGVuZCI6ImRvY2tlcmZpbGUudjAifQ==","os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:49a0b15145b6415d136ba894bd24d77efc211c25e5d46c81ee5669920af19658"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a new file mode 100644 index 000000000..96878321c --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a @@ -0,0 +1 @@ +{"architecture":"amd64","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-10T20:56:22.923857404Z","history":[{"created":"2023-03-10T20:56:22.923857404Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"moby.buildkit.buildinfo.v1":"eyJmcm9udGVuZCI6ImRvY2tlcmZpbGUudjAifQ==","os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:49a0b15145b6415d136ba894bd24d77efc211c25e5d46c81ee5669920af19658"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e new file mode 100644 index 000000000..83fcb0aaf Binary files /dev/null and b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/blobs/sha256/da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e differ diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/index.json b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/index.json new file mode 100644 index 000000000..412dfc6db --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/index.json @@ -0,0 +1,33 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", + "schemaVersion": 2, + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58", + "size": 501, + "platform": { + "architecture": "amd64", + "os": "linux" + } + }, + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790", + "size": 501, + "platform": { + "architecture": "ppc64le", + "os": "linux" + } + }, + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac", + "size": 501, + "platform": { + "architecture": "s390x", + "os": "linux" + } + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/oci-layout b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/oci-layout new file mode 100644 index 000000000..21b1439d1 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/manifestlist-at-root/layout/oci-layout @@ -0,0 +1 @@ +{"imageLayoutVersion": "1.0.0"} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/Dockerfile b/pkg/cli/mirror/testdata/manifestlist/testonly/Dockerfile new file mode 100644 index 000000000..5d2f2270d --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/Dockerfile @@ -0,0 +1,22 @@ +# minimize size by using scratch in builder and final image +FROM scratch as builder + +# Create fake /bin/opm and /bin/grpc_health_probe +# Because these are fake you can never use this as a real catalog +# and there is no way to pre-populate the opm serve cache +COPY opm grpc_health_probe /bin/ + +# Copy declarative config root into image at /configs +COPY configs /configs + +FROM scratch +# Configure the entrypoint and command +ENTRYPOINT ["/bin/opm"] +CMD ["serve", "/configs", "--cache-dir=/tmp/cache"] + +# Use a single copy from the builder to get one layer +COPY --from=builder / / + +# Set DC-specific label for the location of the DC root directory +# in the image +LABEL operators.operatorframework.io.index.configs.v1=/configs diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/README.md b/pkg/cli/mirror/testdata/manifestlist/testonly/README.md new file mode 100644 index 000000000..3a723d1cb --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/README.md @@ -0,0 +1,7 @@ +# NOTICE + +This folder contains all of the information needed to create a dummy OCI layout in the directory called "layout". +This OCI layout can only be used for test case purposes. The images inside the generated manifest list are built +off of scratch in order to minimize its size. While these images contain a declarative config, these are NOT +deployable catalogs since they do not contain real executables nor do they contain any libraries that +would normally be necessary to support an executable. In other words, these image WILL NOT RUN. \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/build.sh b/pkg/cli/mirror/testdata/manifestlist/testonly/build.sh new file mode 100755 index 000000000..4d1994bde --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +# This script assumes the following: +# 1) you are running docker registry locally (e.g. docker run -d -p 5000:5000 --name registry registry:2) +# 2) you have docker buildx setup so that it can access the host network so you can push to localhost:5000 +# (e.g. docker buildx create --use desktop-linux --driver-opt network=host) + +docker buildx build --platform linux/amd64,linux/ppc64le,linux/s390x -t localhost:5000/testonly:v1.0.0 --push . + +skopeo copy --src-tls-verify=false docker://localhost:5000/testonly:v1.0.0 oci:layout --all --format v2s2 \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/configs/aws-load-balancer-operator/catalog.json b/pkg/cli/mirror/testdata/manifestlist/testonly/configs/aws-load-balancer-operator/catalog.json new file mode 100644 index 000000000..c1fc6b54f --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/configs/aws-load-balancer-operator/catalog.json @@ -0,0 +1,146 @@ +{ + "schema": "olm.package", + "name": "aws-load-balancer-operator", + "defaultChannel": "stable-v0.1", + "icon": { + "base64data": "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", + "mediatype": "image/png" + } +} +{ + "schema": "olm.channel", + "name": "alpha", + "package": "aws-load-balancer-operator", + "entries": [ + { + "name": "aws-load-balancer-operator.v0.0.1" + } + ] +} +{ + "schema": "olm.channel", + "name": "stable-v0.1", + "package": "aws-load-balancer-operator", + "entries": [ + { + "name": "aws-load-balancer-operator.v0.0.1" + } + ] +} +{ + "schema": "olm.bundle", + "name": "aws-load-balancer-operator.v0.0.1", + "package": "aws-load-balancer-operator", + "image": "registry.redhat.io/albo/aws-load-balancer-operator-bundle@sha256:50b9402635dd4b312a86bed05dcdbda8c00120d3789ec2e9b527045100b3bdb4", + "properties": [ + { + "type": "olm.gvk", + "value": { + "group": "elbv2.k8s.aws", + "kind": "IngressClassParams", + "version": "v1beta1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "elbv2.k8s.aws", + "kind": "TargetGroupBinding", + "version": "v1alpha1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "elbv2.k8s.aws", + "kind": "TargetGroupBinding", + "version": "v1beta1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "networking.olm.openshift.io", + "kind": "AWSLoadBalancerController", + "version": "v1alpha1" + } + }, + { + "type": "olm.package", + "value": { + "packageName": "aws-load-balancer-operator", + "version": "0.0.1" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJraW5kIjoiU2VydmljZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJsYWJlbHMiOnsiY29udHJvbC1wbGFuZSI6ImNvbnRyb2xsZXItbWFuYWdlciJ9LCJuYW1lIjoiYXdzLWxvYWQtYmFsYW5jZXItb3BlcmF0b3ItY29udHJvbGxlci1tYW5hZ2VyLW1ldHJpY3Mtc2VydmljZSJ9LCJzcGVjIjp7InBvcnRzIjpbeyJuYW1lIjoiaHR0cHMiLCJwb3J0Ijo4NDQzLCJwcm90b2NvbCI6IlRDUCIsInRhcmdldFBvcnQiOiJodHRwcyJ9XSwic2VsZWN0b3IiOnsiY29udHJvbC1wbGFuZSI6ImNvbnRyb2xsZXItbWFuYWdlciJ9fSwic3RhdHVzIjp7ImxvYWRCYWxhbmNlciI6e319fQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJkYXRhIjp7ImNvbnRyb2xsZXJfbWFuYWdlcl9jb25maWcueWFtbCI6ImFwaVZlcnNpb246IGNvbnRyb2xsZXItcnVudGltZS5zaWdzLms4cy5pby92MWFscGhhMVxua2luZDogQ29udHJvbGxlck1hbmFnZXJDb25maWdcbmhlYWx0aDpcbiAgaGVhbHRoUHJvYmVCaW5kQWRkcmVzczogOjgwODFcbm1ldHJpY3M6XG4gIGJpbmRBZGRyZXNzOiAxMjcuMC4wLjE6ODA4MFxud2ViaG9vazpcbiAgcG9ydDogOTQ0M1xubGVhZGVyRWxlY3Rpb246XG4gIGxlYWRlckVsZWN0OiB0cnVlXG4gIHJlc291cmNlTmFtZTogN2RlNTFjZjMub3BlbnNoaWZ0LmlvXG4ifSwia2luZCI6IkNvbmZpZ01hcCIsIm1ldGFkYXRhIjp7Im5hbWUiOiJhd3MtbG9hZC1iYWxhbmNlci1vcGVyYXRvci1tYW5hZ2VyLWNvbmZpZyJ9fQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJuYW1lIjoiYXdzLWxvYWQtYmFsYW5jZXItb3BlcmF0b3ItbWV0cmljcy1yZWFkZXIifSwicnVsZXMiOlt7Im5vblJlc291cmNlVVJMcyI6WyIvbWV0cmljcyJdLCJ2ZXJicyI6WyJnZXQiXX1dfQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"annotations":{"alm-examples":"[\n  {\n    \"apiVersion\": \"elbv2.k8s.aws/v1alpha1\",\n    \"kind\": \"TargetGroupBinding\",\n    \"metadata\": {\n      \"name\": \"my-tgb\"\n    },\n    \"spec\": {\n      \"serviceRef\": {\n        \"name\": \"awesome-service\",\n        \"port\": 80\n      },\n      \"targetGroupARN\": \"\\u003carn-to-targetGroup\\u003e\"\n    }\n  },\n  {\n    \"apiVersion\": \"elbv2.k8s.aws/v1beta1\",\n    \"kind\": \"IngressClassParams\",\n    \"metadata\": {\n      \"name\": \"awesome-class\"\n    },\n    \"spec\": {\n      \"group\": {\n        \"name\": \"my-group\"\n      }\n    }\n  },\n  {\n    \"apiVersion\": \"elbv2.k8s.aws/v1beta1\",\n    \"kind\": \"TargetGroupBinding\",\n    \"metadata\": {\n      \"name\": \"my-tgb\"\n    },\n    \"spec\": {\n      \"serviceRef\": {\n        \"name\": \"awesome-service\",\n        \"port\": 80\n      },\n      \"targetGroupARN\": \"\\u003carn-to-targetGroup\\u003e\"\n    }\n  },\n  {\n    \"apiVersion\": \"networking.olm.openshift.io/v1alpha1\",\n    \"kind\": \"AWSLoadBalancerController\",\n    \"metadata\": {\n      \"name\": \"cluster\"\n    },\n    \"spec\": {\n      \"subnetTagging\": \"Auto\"\n    }\n  }\n]","capabilities":"Basic Install","containerImage":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","createdAt":"2022-06-28T17:56:41","operators.operatorframework.io/builder":"operator-sdk-v1.16.0+git","operators.operatorframework.io/project_layout":"go.kubebuilder.io/v3"},"name":"aws-load-balancer-operator.v0.0.1","namespace":"placeholder"},"spec":{"apiservicedefinitions":{},"customresourcedefinitions":{"owned":[{"description":"AWSLoadBalancerController is the Schema for the awsloadbalancercontrollers API","displayName":"AWSLoad Balancer Controller","kind":"AWSLoadBalancerController","name":"awsloadbalancercontrollers.networking.olm.openshift.io","version":"v1alpha1"},{"kind":"IngressClassParams","name":"ingressclassparams.elbv2.k8s.aws","version":"v1beta1"},{"kind":"TargetGroupBinding","name":"targetgroupbindings.elbv2.k8s.aws","version":"v1alpha1"},{"kind":"TargetGroupBinding","name":"targetgroupbindings.elbv2.k8s.aws","version":"v1beta1"}]},"description":"Operator to simplify management of aws-load-balancer-controller\n\n### Prerequisites for installation\nThe operator requires AWS credentials in the installation namespace before it can be installed.\n\n1. Create the operator namespace with the following command:\n```bash\noc create namespace aws-load-balancer-operator\n```\n2. Create the `CredentialsRequest` in the `openshift-cloud-credential-operator`\n   namespace with the following command:\n\n```\ncat \u003c\u003c EOF| oc create -f -\napiVersion: cloudcredential.openshift.io/v1\nkind: CredentialsRequest\nmetadata:\n  name: aws-load-balancer-operator\n  namespace: openshift-cloud-credential-operator\nspec:\n  providerSpec:\n    apiVersion: cloudcredential.openshift.io/v1\n    kind: AWSProviderSpec\n    statementEntries:\n      - action:\n          - ec2:DescribeSubnets\n        effect: Allow\n        resource: \"*\"\n      - action:\n          - ec2:CreateTags\n          - ec2:DeleteTags\n        effect: Allow\n        resource: arn:aws:ec2:*:*:subnet/*\n      - action:\n          - ec2:DescribeVpcs\n        effect: Allow\n        resource: \"*\"\n  secretRef:\n    name: aws-load-balancer-operator\n    namespace: aws-load-balancer-operator\n  serviceAccountNames:\n    - aws-load-balancer-operator-controller-manager\n  EOF\n```\n3. Ensure the credentials have been correctly provisioned\n```bash\noc get secret -n aws-load-balancer-operator aws-load-balancer-operator\n```\n\nAfter this the operator can be installated through the console or through the command line.\n\n__Note:__ For UPI based installs, additional documentation can be found\n[here](https://github.com/openshift/aws-load-balancer-operator/blob/main/docs/prerequisites.md#vpc-and-subnets)","displayName":"AWS Load Balancer Operator","icon":[{"base64data":"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","mediatype":"image/png"}],"install":{"spec":{"clusterPermissions":[{"rules":[{"apiGroups":["admissionregistration.k8s.io"],"resources":["mutatingwebhookconfigurations","validatingwebhookconfigurations"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["cloudcredential.openshift.io"],"resources":["credentialsrequests","credentialsrequests/finalizers","credentialsrequests/status"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["config.openshift.io"],"resources":["infrastructures"],"verbs":["get","list","watch"]},{"apiGroups":["networking.k8s.io"],"resources":["ingressclasses"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["networking.olm.openshift.io"],"resources":["awsloadbalancercontrollers"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["networking.olm.openshift.io"],"resources":["awsloadbalancercontrollers/finalizers"],"verbs":["update"]},{"apiGroups":["networking.olm.openshift.io"],"resources":["awsloadbalancercontrollers/status"],"verbs":["get","patch","update"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["clusterrolebindings"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resourceNames":["aws-load-balancer-operator-controller-role"],"resources":["clusterroles"],"verbs":["bind","get"]},{"apiGroups":["authentication.k8s.io"],"resources":["tokenreviews"],"verbs":["create"]},{"apiGroups":["authorization.k8s.io"],"resources":["subjectaccessreviews"],"verbs":["create"]}],"serviceAccountName":"aws-load-balancer-operator-controller-manager"}],"deployments":[{"name":"aws-load-balancer-operator-controller-manager","spec":{"replicas":1,"selector":{"matchLabels":{"control-plane":"controller-manager"}},"strategy":{},"template":{"metadata":{"annotations":{"kubectl.kubernetes.io/default-container":"manager"},"labels":{"control-plane":"controller-manager"}},"spec":{"containers":[{"args":["--secure-listen-address=0.0.0.0:8443","--upstream=http://127.0.0.1:8080/","--logtostderr=true","--v=0"],"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc","name":"kube-rbac-proxy","ports":[{"containerPort":8443,"name":"https","protocol":"TCP"}],"resources":{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"5m","memory":"64Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]}}},{"args":["--health-probe-bind-address=:8081","--metrics-bind-address=127.0.0.1:8080","--leader-elect","--image=$(RELATED_IMAGE_CONTROLLER)","--namespace=$(TARGET_NAMESPACE)"],"command":["/manager"],"env":[{"name":"AWS_SHARED_CREDENTIALS_FILE","value":"/etc/aws-credentials/credentials"},{"name":"RELATED_IMAGE_CONTROLLER","value":"registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece"},{"name":"TARGET_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.annotations['olm.targetNamespaces']"}}}],"image":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","livenessProbe":{"httpGet":{"path":"/healthz","port":8081},"initialDelaySeconds":15,"periodSeconds":20},"name":"manager","readinessProbe":{"httpGet":{"path":"/readyz","port":8081},"initialDelaySeconds":5,"periodSeconds":10},"resources":{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"10m","memory":"64Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]}},"volumeMounts":[{"mountPath":"/etc/aws-credentials","name":"aws-credentials"}]}],"securityContext":{"runAsNonRoot":true,"seccompProfile":{"type":"RuntimeDefault"}},"serviceAccountName":"aws-load-balancer-operator-controller-manager","terminationGracePeriodSeconds":10,"volumes":[{"name":"aws-credentials","secret":{"items":[{"key":"credentials","path":"credentials"}],"secretName":"aws-load-balancer-operator"}}]}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["configmaps"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":["coordination.k8s.io"],"resources":["leases"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":[""],"resources":["events"],"verbs":["create","patch"]},{"apiGroups":[""],"resources":["secrets","services"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":[""],"resources":["serviceaccounts"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["apps"],"resources":["deployments"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["rolebindings","roles"],"verbs":["create","delete","get","list","patch","update","watch"]}],"serviceAccountName":"aws-load-balancer-operator-controller-manager"}]},"strategy":"deployment"},"installModes":[{"supported":true,"type":"OwnNamespace"},{"supported":true,"type":"SingleNamespace"},{"supported":false,"type":"MultiNamespace"},{"supported":false,"type":"AllNamespaces"}],"keywords":["aws","load-balancer","ALB","ingress"],"links":[{"name":"Aws Load Balancer Operator","url":"https://aws-load-balancer-operator.domain"}],"maturity":"alpha","minKubeVersion":"1.20.0","provider":{"name":"Red Hat","url":"https://redhat.com"},"relatedImages":[{"image":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","name":"aws-load-balancer-rhel8-operator-95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d-annotation"},{"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc","name":"kube-rbac-proxy"},{"image":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","name":"manager"},{"image":"registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece","name":"controller"}],"version":"0.0.1"}}" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"apiextensions.k8s.io/v1","kind":"CustomResourceDefinition","metadata":{"annotations":{"controller-gen.kubebuilder.io/version":"v0.5.0"},"creationTimestamp":null,"name":"targetgroupbindings.elbv2.k8s.aws"},"spec":{"group":"elbv2.k8s.aws","names":{"kind":"TargetGroupBinding","listKind":"TargetGroupBindingList","plural":"targetgroupbindings","singular":"targetgroupbinding"},"scope":"Namespaced","versions":[{"additionalPrinterColumns":[{"description":"The Kubernetes Service's name","jsonPath":".spec.serviceRef.name","name":"SERVICE-NAME","type":"string"},{"description":"The Kubernetes Service's port","jsonPath":".spec.serviceRef.port","name":"SERVICE-PORT","type":"string"},{"description":"The AWS TargetGroup's TargetType","jsonPath":".spec.targetType","name":"TARGET-TYPE","type":"string"},{"description":"The AWS TargetGroup's Amazon Resource Name","jsonPath":".spec.targetGroupARN","name":"ARN","priority":1,"type":"string"},{"jsonPath":".metadata.creationTimestamp","name":"AGE","type":"date"}],"name":"v1alpha1","schema":{"openAPIV3Schema":{"description":"TargetGroupBinding is the Schema for the TargetGroupBinding API","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"TargetGroupBindingSpec defines the desired state of TargetGroupBinding","properties":{"networking":{"description":"networking provides the networking setup for ELBV2 LoadBalancer to access targets in TargetGroup.","properties":{"ingress":{"description":"List of ingress rules to allow ELBV2 LoadBalancer to access targets in TargetGroup.","items":{"properties":{"from":{"description":"List of peers which should be able to access the targets in TargetGroup. At least one NetworkingPeer should be specified.","items":{"description":"NetworkingPeer defines the source/destination peer for networking rules.","properties":{"ipBlock":{"description":"IPBlock defines an IPBlock peer. If specified, none of the other fields can be set.","properties":{"cidr":{"description":"CIDR is the network CIDR. Both IPV4 or IPV6 CIDR are accepted.","type":"string"}},"required":["cidr"],"type":"object"},"securityGroup":{"description":"SecurityGroup defines a SecurityGroup peer. If specified, none of the other fields can be set.","properties":{"groupID":{"description":"GroupID is the EC2 SecurityGroupID.","type":"string"}},"required":["groupID"],"type":"object"}},"type":"object"},"type":"array"},"ports":{"description":"List of ports which should be made accessible on the targets in TargetGroup. If ports is empty or unspecified, it defaults to all ports with TCP.","items":{"properties":{"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"The port which traffic must match. When NodePort endpoints(instance TargetType) is used, this must be a numerical port. When Port endpoints(ip TargetType) is used, this can be either numerical or named port on pods. if port is unspecified, it defaults to all ports.","x-kubernetes-int-or-string":true},"protocol":{"description":"The protocol which traffic must match. If protocol is unspecified, it defaults to TCP.","enum":["TCP","UDP"],"type":"string"}},"type":"object"},"type":"array"}},"required":["from","ports"],"type":"object"},"type":"array"}},"type":"object"},"serviceRef":{"description":"serviceRef is a reference to a Kubernetes Service and ServicePort.","properties":{"name":{"description":"Name is the name of the Service.","type":"string"},"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"Port is the port of the ServicePort.","x-kubernetes-int-or-string":true}},"required":["name","port"],"type":"object"},"targetGroupARN":{"description":"targetGroupARN is the Amazon Resource Name (ARN) for the TargetGroup.","type":"string"},"targetType":{"description":"targetType is the TargetType of TargetGroup. If unspecified, it will be automatically inferred.","enum":["instance","ip"],"type":"string"}},"required":["serviceRef","targetGroupARN"],"type":"object"},"status":{"description":"TargetGroupBindingStatus defines the observed state of TargetGroupBinding","properties":{"observedGeneration":{"description":"The generation observed by the TargetGroupBinding controller.","format":"int64","type":"integer"}},"type":"object"}},"type":"object"}},"served":true,"storage":false,"subresources":{"status":{}}},{"additionalPrinterColumns":[{"description":"The Kubernetes Service's name","jsonPath":".spec.serviceRef.name","name":"SERVICE-NAME","type":"string"},{"description":"The Kubernetes Service's port","jsonPath":".spec.serviceRef.port","name":"SERVICE-PORT","type":"string"},{"description":"The AWS TargetGroup's TargetType","jsonPath":".spec.targetType","name":"TARGET-TYPE","type":"string"},{"description":"The AWS TargetGroup's Amazon Resource Name","jsonPath":".spec.targetGroupARN","name":"ARN","priority":1,"type":"string"},{"jsonPath":".metadata.creationTimestamp","name":"AGE","type":"date"}],"name":"v1beta1","schema":{"openAPIV3Schema":{"description":"TargetGroupBinding is the Schema for the TargetGroupBinding API","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"TargetGroupBindingSpec defines the desired state of TargetGroupBinding","properties":{"ipAddressType":{"description":"ipAddressType specifies whether the target group is of type IPv4 or IPv6. If unspecified, it will be automatically inferred.","enum":["ipv4","ipv6"],"type":"string"},"networking":{"description":"networking defines the networking rules to allow ELBV2 LoadBalancer to access targets in TargetGroup.","properties":{"ingress":{"description":"List of ingress rules to allow ELBV2 LoadBalancer to access targets in TargetGroup.","items":{"description":"NetworkingIngressRule defines a particular set of traffic that is allowed to access TargetGroup's targets.","properties":{"from":{"description":"List of peers which should be able to access the targets in TargetGroup. At least one NetworkingPeer should be specified.","items":{"description":"NetworkingPeer defines the source/destination peer for networking rules.","properties":{"ipBlock":{"description":"IPBlock defines an IPBlock peer. If specified, none of the other fields can be set.","properties":{"cidr":{"description":"CIDR is the network CIDR. Both IPV4 or IPV6 CIDR are accepted.","type":"string"}},"required":["cidr"],"type":"object"},"securityGroup":{"description":"SecurityGroup defines a SecurityGroup peer. If specified, none of the other fields can be set.","properties":{"groupID":{"description":"GroupID is the EC2 SecurityGroupID.","type":"string"}},"required":["groupID"],"type":"object"}},"type":"object"},"type":"array"},"ports":{"description":"List of ports which should be made accessible on the targets in TargetGroup. If ports is empty or unspecified, it defaults to all ports with TCP.","items":{"description":"NetworkingPort defines the port and protocol for networking rules.","properties":{"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"The port which traffic must match. When NodePort endpoints(instance TargetType) is used, this must be a numerical port. When Port endpoints(ip TargetType) is used, this can be either numerical or named port on pods. if port is unspecified, it defaults to all ports.","x-kubernetes-int-or-string":true},"protocol":{"description":"The protocol which traffic must match. If protocol is unspecified, it defaults to TCP.","enum":["TCP","UDP"],"type":"string"}},"type":"object"},"type":"array"}},"required":["from","ports"],"type":"object"},"type":"array"}},"type":"object"},"nodeSelector":{"description":"node selector for instance type target groups to only register certain nodes","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","items":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","items":{"type":"string"},"type":"array"}},"required":["key","operator"],"type":"object"},"type":"array"},"matchLabels":{"additionalProperties":{"type":"string"},"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object"}},"type":"object"},"serviceRef":{"description":"serviceRef is a reference to a Kubernetes Service and ServicePort.","properties":{"name":{"description":"Name is the name of the Service.","type":"string"},"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"Port is the port of the ServicePort.","x-kubernetes-int-or-string":true}},"required":["name","port"],"type":"object"},"targetGroupARN":{"description":"targetGroupARN is the Amazon Resource Name (ARN) for the TargetGroup.","minLength":1,"type":"string"},"targetType":{"description":"targetType is the TargetType of TargetGroup. If unspecified, it will be automatically inferred.","enum":["instance","ip"],"type":"string"}},"required":["serviceRef","targetGroupARN"],"type":"object"},"status":{"description":"TargetGroupBindingStatus defines the observed state of TargetGroupBinding","properties":{"observedGeneration":{"description":"The generation observed by the TargetGroupBinding controller.","format":"int64","type":"integer"}},"type":"object"}},"type":"object"}},"served":true,"storage":true,"subresources":{"status":{}}}]},"status":{"acceptedNames":{"kind":"","plural":""},"conditions":[],"storedVersions":[]}}" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"apiextensions.k8s.io/v1","kind":"CustomResourceDefinition","metadata":{"annotations":{"controller-gen.kubebuilder.io/version":"v0.9.0"},"creationTimestamp":null,"name":"awsloadbalancercontrollers.networking.olm.openshift.io"},"spec":{"group":"networking.olm.openshift.io","names":{"kind":"AWSLoadBalancerController","listKind":"AWSLoadBalancerControllerList","plural":"awsloadbalancercontrollers","singular":"awsloadbalancercontroller"},"scope":"Cluster","versions":[{"name":"v1alpha1","schema":{"openAPIV3Schema":{"description":"AWSLoadBalancerController is the Schema for the awsloadbalancercontrollers API","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"AWSLoadBalancerControllerSpec defines the desired state of AWSLoadBalancerController","properties":{"additionalResourceTags":{"additionalProperties":{"type":"string"},"description":"Default AWS Tags that will be applied to all AWS resources managed by this controller (default []). \n This value is required so that this controller can function as expected in parallel to openshift-router.","type":"object"},"config":{"description":"Config specifies further customization options for the controller's deployment spec.","properties":{"replicas":{"default":2,"format":"int32","type":"integer"}},"type":"object"},"enabledAddons":{"description":"AWSAddon describes the AWS services that can be integrated with the AWS Load Balancer.","items":{"enum":["AWSShield","AWSWAFv1","AWSWAFv2"],"type":"string"},"type":"array"},"ingressClass":{"default":"alb","description":"IngressClass specifies the Ingress class which the controller will reconcile. This Ingress class will be created unless it already exists. The value will default to \"alb\".","type":"string"},"subnetTagging":{"default":"Auto","description":"SubnetTagging describes how resource tagging will be done by the operator. \n When in \"Auto\", the operator will detect the subnets where the load balancers will be provisioned and have the required resource tags on them. Whereas when set to manual, this responsibility lies on the user.","enum":["Auto","Manual"],"type":"string"}},"type":"object"},"status":{"description":"AWSLoadBalancerControllerStatus defines the observed state of AWSLoadBalancerController.","properties":{"conditions":{"description":"Conditions is a list of operator-specific conditions and their status.","items":{"description":"Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions.  For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }","properties":{"lastTransitionTime":{"description":"lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.","format":"date-time","type":"string"},"message":{"description":"message is a human readable message indicating details about the transition. This may be an empty string.","maxLength":32768,"type":"string"},"observedGeneration":{"description":"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.","format":"int64","minimum":0,"type":"integer"},"reason":{"description":"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.","maxLength":1024,"minLength":1,"pattern":"^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$","type":"string"},"status":{"description":"status of the condition, one of True, False, Unknown.","enum":["True","False","Unknown"],"type":"string"},"type":{"description":"type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)","maxLength":316,"pattern":"^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$","type":"string"}},"required":["lastTransitionTime","message","reason","status","type"],"type":"object"},"type":"array"},"ingressClass":{"description":"IngressClass is the current default Ingress class.","type":"string"},"observedGeneration":{"description":"ObservedGeneration is the most recent generation observed.","format":"int64","type":"integer"},"subnets":{"description":"Subnets contains details of the subnets of the cluster","properties":{"internal":{"description":"Internal is the list of subnet ids which have the tag `kubernetes.io/role/internal-elb`","items":{"type":"string"},"type":"array"},"public":{"description":"Public is the list of subnet ids which have the tag `kubernetes.io/role/elb`","items":{"type":"string"},"type":"array"},"subnetTagging":{"description":"SubnetTagging indicates the current status of the subnet tags","enum":["Auto","Manual"],"type":"string"},"tagged":{"description":"Tagged is the list of subnet ids which have been tagged by the operator","items":{"type":"string"},"type":"array"},"untagged":{"description":"Untagged is the list of subnet ids which do not have any role tags","items":{"type":"string"},"type":"array"}},"type":"object"}},"type":"object"}},"type":"object"}},"served":true,"storage":true,"subresources":{"status":{}}}]},"status":{"acceptedNames":{"kind":"","plural":""},"conditions":null,"storedVersions":null}}" + } + } + ], + "relatedImages": [ + { + "name": "controller", + "image": "registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece" + }, + { + "name": "", + "image": "registry.redhat.io/albo/aws-load-balancer-operator-bundle@sha256:50b9402635dd4b312a86bed05dcdbda8c00120d3789ec2e9b527045100b3bdb4" + }, + { + "name": "aws-load-balancer-rhel8-operator-95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d-annotation", + "image": "registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d" + }, + { + "name": "manager", + "image": "registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d" + }, + { + "name": "kube-rbac-proxy", + "image": "registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc" + } + ] +} diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/configs/node-observability-operator/catalog.json b/pkg/cli/mirror/testdata/manifestlist/testonly/configs/node-observability-operator/catalog.json new file mode 100644 index 000000000..2a9882abf --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/configs/node-observability-operator/catalog.json @@ -0,0 +1,158 @@ +{ + "schema": "olm.package", + "name": "node-observability-operator", + "defaultChannel": "alpha", + "icon": { + "base64data": "iVBORw0KGgoAAAANSUhEUgAAAKgAAACjCAYAAAAejFV3AAAvs0lEQVR4Xu1dB3gURRueAKFIEwi9SUeKVJGOIk1QpIMoIIrSBAQElRoUEEGKgIIgHSkhEBCkRVoS6m3ogsiPNEF6EZSW3Pzvu7OHcXNJ7i4XIMl+z/M+u3e3d7cz887XpqwQllhiiSWWWGKJJZZYYoklllhiiSWWWGKJJZZYYoklllhiiSWWWGKJJZZYYoklllhiiSWWWGKJJZZYYoklllhiiSWWeFN85H+R8hchUh8XIs1JIdI6Az/ThPANwLWO7/F3zD9siSXuik6mLUKkIskOCJF+nxBPg2x+QO7dQhQKF+I5oBZeN8Hr5nuEaBEVNiFeB+rh8xdw3bNhQhTA+7lwbbZdQmTaIUQ6EpxEN4hriSUxC0niL0SKtUrrZQaZ8uNYEeRquFeId3Echdc/4Lgdx9+AM8CfIOEVHK8C10zge5eA88Ap4ACwAZiB7wwE2uF364CspUhcdIYM+MyX92AR1hJdSASSguTYLkQOkK8oXjcAPsX5Uhz34ngRuAfY8Vp6Cfytv4GTIGqopkj7Pv6jKrRqASDrWWhYS7smQzF8wZQ0sdBeOTWlJTsDs3B+BLjjhFCPAnbcwzUgBOdj6CbQNSBZ6WbgnlOYy2JJEhKDmKnoS0JblUDjNwcRJgPhmjLHEU5I8zhAot7F8TyOwXADhhi+bAH6wgy4hKVVk46QmGjU1NRE0JjPQTN1R2OvRqNf0J4cUsaGB8AxYAbuvQ2CrOIMshjAWeY/EYvDvyQxoXlewPlQYBfwFxDphAhPNGyqMzHoWgl0wesyJCrdFWERNXEJzSAaMTPMeXk0ZF+ch9gUMb0Z6DwWGERlZiAALsBb+6FR0QkzWD5qIhA2EoMfRORF4Lu9g8bciIa8pSUBYpoBckaifGdxPhfH11HePEYwZWnTJ1Hok6GRsqPhGgGzgT8MbROtcZMQ2PHuAQdQ9s+YpjoBy2Fp0ydIqDFOCpEWjVQS6I1GsmkqCjY3ZpKGkaJaAaK2OyREfkubPgFCTcG0ERqmLrTlYhyva0nQnLsD1MFxYBRQKUyIjJY2fUxCk44AIS+I2RENswX4x9xYyRH0TYFL0KTz6O7gPT8jd2rJoxJOsoDmLIbK/xg4mgx8TU/ADrsJ6HRAiHzs0OZ6tCQBhFE6Kr0iMB64rCXCnOYjxH3gIDTpANRbUU6EsfzShBMm3p+C6aqG4xxNzRhK1v6mi7DDwvyK4zAm96FJ01okTQDZIET6PULUQUUHaZa/6QnOQpOOBZ5j1sMiqReFU89QwS8xjQLcdlL5FuIGrc0ZkpRzEpiGMtezJR4IezsqtaqmxqA5h9Jc8RbcAOryJI6j4ZOWZbBprm9L3BD6S+jtVeE7LdPUiEm0Cn8cCFfaSAfTOppChE3NPCKY6uF7D68z/4arwG9KuDZyN7DLAM/5Hj8zX+8KcG/n4MuPwfdL4LWvud4tcUFYcQfRy3GcCdw0SBGtsh8RHhIxXHUUTjxhBoFj4SdsajrcQU3NLd2Ha37B8ThwyqbmdTKgo9+sk5e/Z8D8Pw9BAoYBwcBKYBEwF5gHLAFWA1uFIqwHROV/M3D6hOur4khB6euz/IVIQZg/TJaCCknJikPFj9Ue3+gQo19qRRKL6470dUV4/TMwH6T7Eq/7gUhv49ga7zWGVnoZ5w1sasHcGzjvhusG4/gNjquAHTg/CpzH5zdtiuz/SZORbCFAEPA10AdoDtQAygMVgTpAe8AfWAD8LBRRo/6OC2Cd7sP/deWaKPOIk0HKVECGL4XINwp+62ghiuP1U1GvS3bCiuH6IFRaH5uaVPyoyUnCkDicZU8yrcd9TAa5uuJYA69zc2Y7/TdqnpiiYb7PRsf1vvSjOSSL75UwyDsYvzffphbgndbUjCtqV/s2fPVboBVQGMgEZDCOmY3ztAAiHJlNKOIOFkrLwq90V5uynFxi0ppzS/1xvxx1wjHtOLTBF0JUADHb4PgVjqEg6MIxQlR/Pzm7BWj0DNBErVBp+zQ3R4jYOATNY1Q43jdfbwKJySDsdLiaPzoVxzfxuizJ5a3hQhLXWC/P5cu1cH8f4TxAU6s+L/8I0vQCUV/ApWWBqsArQDvgLaG0aW2gFJADSA8UA3oAuEe5U5XFZaCcd1DOxfhejVlC5AEBS4OQjUDGQcC6kbAcn+GeAPvnQlzCe+OoUWPqmElaUGG+aLTKqLRgTWmUaBXqDCQhtQdNHU3jQmA2MAdYLP7119h4ToiqEzNcrbBch87xCc6rGrPVE7wRSHz8fwH8b0v8/5StQuz8AZZjCkiBMthBWN3kOzoay7BeKC37HlBZKE1KbQtiS17PIMpcR87A36NrECrEn/je/ElCDAMBl0FbngYZH4CU0gG8liCrBIH3jhei7QQh0pnLkqTFH+Zlj1qLzoVsLuc62RgbgRnAAKAJUBrIBxQCqgBtgeFCBRm81vDX6DpwKPBPYD3QjzPwjdnpCU5Ms9BdMOazNkQ9TES59u728bkJRDqL2vl6M/CNUFq1gFFWEEhuMV0bFQ4Lgw5tx/ftawB06IjJ6KQg5t8gYoSZmHhfQmtKkFJOhe+Mup6Fzl/ycdTTYxNqLKCDTUXGcfqdrGj0fF1D9hdKk2QFYIclQlLdT8solO+WBXgGeBH4SOiBRSQa5yYaXgtXgVhNuhaPucL532me9fPL/U62bPXGZc369cxs2Y7Ny5Ll3g8ZMsjlqVPLDSlS6JE9CeaoB5KXgRKDJpp9ugGBxvtR68thZbaibqGB7dDc9unAOGW6HxIyKilh6iU+lyCvrgBokeYL/f9+BbquTi4B03cw7TSrIF2Y5oLfSXI6gonGwNNCkTI9kEco3+1F4HWhgo1mQD2gkvos4lUEQGiEdT/BrILkWR4zMSkpM2XKlLVYsWIv1KhR48OmTZsGdOrU6XDvnj2v9u/a9X6/tm3tA2vVkqMLFZJzQdaNKVP+x10h+Zh6op/Kco4VyqXh+7wuRJEychmOM2MhJU34aOP7zCCAwDop2QGiAhr3AY6rgIoBXvLNn2iB9vIDQSdoKr8YjZBmgFQ6OesIRUpGtAWBBkJpU/b2VUKZ801C5RJpyuYhIPgYvb8m/K3i8KNeRPDzJJAzT548+StWrPhWq1atAkaNGnV23bp193/99Vd54cIFeenSJXnq1CkZGhIip40bJ4c1aSLH580rg6BRt/v4PCQptSPqxA53xt4PBEJUfwflvodj5Fy8B8LZqRGdEdNByolCuQzfC5VvNRMzKqBJT+P4MQj8tLlASUoY0Rr5Q5dMOzUCK68RAC9dJ2gFAMSTK4zPzd8xfpd5xzC4EX2gbYpUU07+4yZnKpCzwIsvvvhBr169dgQFBd0+f/68PSIiQprFbrfLW7duyW2bN8sxPXrI0cWLy8A0aXSSGuW7j45+YwSibgRLO9BJ1yAqt0Fb3oBmtJtJSRNOfxUBD/1KCc2q++hmIsYAO3AHWAqilnkCOnnCCAqWAoR6BpU7z+aiaYcmlB2E8ivpX1KLsueHGp+bvxNukBPHtTB5bWHqsj4hFeqTL1++vFWqVPlg0KBBu0JDQ/+5efOmTsTY5N69e/Lg/v3y64ED5RiQdEXq1Pd3+vgw0NvNelyHYA+atBYCmqIIbDqAiJtBylsgpd1Byq+E8ivhWrlLygjgb+APmPkdOI75AYHlE1Kf3heYpXRw5ttrLmpPBgh02p8RSnNCC+oVzffN1xpwaM51wOuPKnXkihQtWjRTpUqVWvfu3XtDcHDwXzdu3LDHRU6HPHjwQGp79siJPXtGfFm06PGladJMRgd9lZ39ZJSpdKirHCBkV2AXzu9MEsqvhGaN04QTCxUpI4E70JR/4rgXCMT5EBzrM2/K+MFctiQhrERWKIizSnNBe9Lh52hJU6E0ZxmhtEGIk2sNcKjyJrTLRgQVb8A39cPfpitdunRqoYb1HhtRYdJTgaBVO3bsODcwMPAifE17ZGSkmYexyt27d+XmTZvu9e3de2utF15oVbhw4czCSZngW+aCRu0Hv/IwiHUPiEZEJ4jEdXdxvAwcAVHX4DgKx+bQmAWTRWAUoLTnG+Fqe8M4tSdzl/STSgBFgA+FygM6M+skc5iPz/0fU6U67J827ZjKfn7t8uXO3TJnzpyvZc+evRZMa7FnnnmGzj2C/+iNmtBSpEiRHPXq1es7ceLEQwiG7kPM/ItTqG0RQNlnzpx5rWXLlpPKli1bUjiZ9EFFAJ+7OAg2doEKbGimzYQkHNryNoh4AggGvgZRO8wVojS0ZUb/5DJZhJWGwCgPyLTU5uKIEQnK3v8q0FOoKJ1ENF+3HQAx5bcZM/4zoHTpX99s0iSsU8eO+7p06XL07bffPti6devNDRo0mA7frxtIWjVXrlzZxSM0UzDrvtDiNWHaF2/cuPHa9evX4/Q7YxIGU3v27LEPHjw4tHr16q2yZMniVIvSDEPz1Qb5lgLXDTI6THgEjrcM8u5EHc/D8QO4ANUWJdcVoYg2U4GY9W1qllA0kjkDNSXJhyDAaUDE19sQ0c5Lm1YOLlxY9mvZ0j554kT71q1b5e+//26/ePGi/cyZM/Zdu3bZ58yZE9G3b98rr7322try5cv3yJ8/fxlo1UcS1eN/stasWbPHlClT9p04ceKes4jdHfnrr7/k3LlzL7z66qtfwMwXEzEQCkTLQG0I8u0BIe8QOL8A7MX5EhD4YxCyDq7L6p9cNGVMwh3njLxnnL6nGWZiOkByfpcunexbrpycMHy4HkQwKjb7dnxN/+3kyZP2gICAOz169DgG7fM1zG51Pz+/jCJhSepTsGDBZzt06DA5KCjo/JUrVzxTnVGE2ncTfFGUY2W5cuVeMjraf4QWi5oQKLtMiBnLQcxAEHMx4iiQtgW0ZXESmFkV83eTnbCiQM5KINV+zQXf0xXA35SzSc4KFeSUsWPlmdOndfMXm7Bh//77b0mNOnz48AsNGzacXapUqZezZs2KGCzBSJqiTJky9QcNGrRm586dt/j/3hD4sfbRo0cfRPD1LjW0MO6fhDur1nPlZp0zYwLrsxQ4B2s0f4cQFbRH6N4kCtmi1hh9oLkxISQ20A8N8vWVH5UsKaeMGiX/OHs2mtaMTUjk3377zT5u3LjLjRs3no/oug6CqfQiAUhK7Va3bt3OEyZM2OtpcORMoIklgqULr7/22ogKhQoVnCxEmoNCZIGfXwpoinoaEq6yJb9ragI2LddufPbGr2p7HK+XNdEKem1WTa3OjPeGCzT3m6A9x2XPLod16yaPHD6s5wjdFRLll19+iYQWOofoenLx4sXLgahpzPceT/FBUJarRYsWg+Aznjh37lykOx0pNrlz545cHhh4+9127eb3zpnzdSiBRui4vVFHc4Fwm/Mtzun/fwWtWsgy7YawItBry2lqA9ZohHMXHNacnzq17FOligxeu1b+888/5rZzWThCo2laJMzvsVq1ag0oBE0kYgg4PBSf7NmzF+vYseP4VatWnbt69apT/5OuBzsZ74dHVyJ8En3b1q0PRrRvf3ha5sxrw4SwGaSMTQnQveLWOA1o1cw3myyFoxwgaHebl56ksRnac7Sfn/Tv2VNevHDBpcaMTTjWvX79+judO3feVLFixRYc7TGXwUPx8ff3TwGClkcwMyM4OPgSou9oN0tCcoLI7t275YYNGyT8VHn+/Hldw8cmLLeG73zdrl3E3EyZIsJc9+1PwZINQJtkT/ZmnhWACvEDORdosfdsl0DzvhK+Z//y5WXQkiXx0p5R5cyZM/Kbb7651LRp06mlS5cuJZwkvz0Qn9atW6eED/rCJ598Mh/Eu3r79u3//C8Dpr1798rx48dLuAGyevXqsnnz5vLbb7+Vx48fj5Okhw4ckFPeflt+//TTsY2umXEb9TgP7kB5pv7MN52shOYdJvlZVMhhzfUeHiOYE/0uQwbZv1UreezIkTijdleFRACBIgYMGGADSTpEjYrjIT4c3ixQoEDNwYMHL4ErcT1qh2Laa8+ePbJXr14SroVMDbclRYoUMk2aNLIK3Jc5c+bogVBs8uvRo3Ia/PAZWbPqc2XN9RUDOBxsA0HbcF6E+aaTlTiS85qLcz7jAtcfjcqRQ341aJC8isaLr3l3iGMIEaS4hKh+Ksx8vLUoyYkAKW3+/PlrDxkyZKmZoCdOnJBwAeSzzz6rkxNf0UGSZsuWTX700UfMNMTaCY/9+utDgrqhQQmu7x8a+mRM3H58wnmf8HcGeit6Xw3/c0DhwjJg7lyvmXeHUIuGhYXd/+CDD7ZWrVq1KXzHDObyuCM1atTICHchKwhaC0HYD/AxrzlyoNSeAQEBEiSW6dOn10npg7I5QC365ptv6n4pr41JmMH4pksXOTNLFncJyvaYx/1Wk+WwpkO4GE1Tz7+Mt3knQQPRkB/A/wzdvFmPeL0p1KIcHp04ceLJBg0aDIYWzSfikYp55ZVXsoOA+YoUKVLjww8/nLNt27YrHKLk/5w+fVp++umnsmDBgjJz5swyT548MgcsQ7p06WTKlCllqlSpZLNmzeSWLVti7Yj7wsPlZBB5dqZM+lCwuc5iA5TGNgRKryTbDcVoOrapFZtcpBZvgjI5vxSmsHfduvIXBAexmT6HkAwOuCIk0MqVK2+2a9dufpkyZSrHJy/66quv5q1Xr15haNDK77zzztQ1a9ZcuH79uj5zHmSVbdu2lSVLltSDohEjRugmvVq1ajITyEYNinuQO3bsiFGDsky7wsLk1/g+F9jRPzfXWRz4De3Sk+v/k6WZp+nYpXao4y4a5spxG5zZtOCpp+SHLVvKk/DfYkt4kwQMMPbv3y+3b9/OhLy8du1anKTmb8Ks3ofG2wqyNDPG6T0SB0GLFy9eEmT7fMmSJac5B5RmfunSpbJ+/fqyadOmMjAwUL9XalUStVixYjILTDZcDXkEgWBMgxAP4JJsWLlSToCbsByaN4ZlL7GBSftxQAH/eFiKRCsMkFD4ZpraRMtcOW6DDTAbmqJ3+/Z6Y8ZEUJKQn8+aNUv34xo2bCihweT333+vBx1xpW6OHz8eOWbMmCNcM2RMy/NIuyDYygWCFqhUqVJunPeeNm3aEbgQETdu3NAj9Nq1a+taMjg4WDL9xA40efJkWa5cOZ2kX3zxhTx37lyM2p/aftH06fKrsmXlWl9fp9MQ4wD3B1gElJXJ0Q/lPkYofDejIsyV4zZI0O8zZrT37tgxknnLmAhKbUQyItDRAxD6dDyy4YcNGyYPI7CIzX+llsP3/4QGHA0zn1+oxnObpDVr1sxSq1Yt+qEZcC8tRo4cuQ0a/Q7vjwSlOa9YsaJEACVXr14tFy1aJNuj8yHyl40aNZJBQUH6zKyYhHXw3dChcgr82M3wzc315SK2MMuSLPcM5VAaKuBzJ5XiEUjQWRkzRvbq2PE+53g6IyjNoc1mky3hBtBMMiLGrehHBh4wt3LUqFHy5MmTMZp7aiaY3dvQvrNAopJMFwkPCEr/FcHPUzhNVbhw4edhsudBW17hHFWa9ZdffllmzZpVz4GCyLJy5coyd+7cskSJEnr66dixYzGad8qeXbvk+DfekHNQzlC1ytMTHIYP2ilZ5kNR+Kc09eADc6V4BBJ0bvr093u2b3/71KlTTglK/2758uW6ZmJE7CAowXO+R9NKH5Cm1pn55CSMn3766X7nzp1XVK9e/XkjUHKboEJ9h76dT968efNBIw+ZO3fub2fPnn3A9BHdDrgQeg40bdq08in41wioZJcuXSQnXHMINiahBVi5cKH84vnn5XIEVPTPzfXlIjg/4mPObjLffJIXpphgPn5yUikeYbcQEfPSpbvapVWr8//73/8inGlA+nEzZszQo2M2vCOvyDyjA0zn9OzZM8YAhI0PTRf5/vvvB4OgdQ0t6ImQoDr4G3Axmg8dOjQYGv72H3/8IRcsWCCbNGmim3SmmeiCdO/eXW7cuFHGtiSE73NThxkDB8rJ0LjBPv9u5OABbgJf7VF7hUbrhP7oYLCEGRYLkR9Bb66ApOQKsFdq6lnt5krxCKjEu/N8fX9rW6/eMU3THjgjF3fkYKDBIIOpGoKNj0BFlkUwQbNPTcUE+apVq/TgxCz83bCwMHv//v231a1b9xVjnqgn4iCofg4zX7xNmzZfgZhnQdBIkpT3gIBMDh8+nHM75b59+/R7iomcFFqJNStWyK/q15fL4Ft7EL1HBbeenLlbza7XAyV/oe+qnHqVEDnxXs0lQvRYimgfeI/vOSNyohSuR9fUltPmSnELjE5DhbCvFeLehBQpzrd87rmL69esiXSWH7x69ar87rvvdA2aARE/hxGZX1y2bJkemDD3mD17dgmzrRPD2Vg3XQf6sUOGDAl75ZVXXitdunQGc9lclKgEFdSiFSpUaDlgwIDg0NDQWwyAmIS/fPmy3rFo0p11uqjCezty6JCc3KePnFKggNyEADAe2pPJej6AlwMpfEia7wohsoGQz4OMb3FpyCIhNgIngat4b16gEMWSDEFR4Mzhas/2aBUTF0jK7SDlz0CQ0PdXipyC42Afn8h2aJhZ334rbzvx0djIHEIEEXTN+QaCCJKNqSV+xkiZmtRh5qnFzOIgKMxxfAlqFpr6Ag0bNvx4/Pjxhw4fPnzPWSeLSahVeb/zJ06UY+FjL4ffGk/tSTxAXQdvFuIdELANSDkcZAz6QYhjxgI7fSUoXt/B5wt/gqZN1gQlMeHzcANX7l9pnybUrmwjhdpfaBDQwc9PDu/fX9c6ZlNIIoaEhOi5z0KIjhHo6GklaiaS4ccff9SjZU7GYJBCX878G/RtOYIDTRdSv379xs8995ynJj6aMCNQpEiRSs2bN58Kk36GedG4tCaF90jrsCIg4O7nDRv+PTdTpgchnkfuOhhYwTJFbhDiTKAQ20HMQ6jzawvULnY6MR1I1gSF/2PfCqDwdpgX+wxggtB3ZfvP5lfEMKAH/K5uzZvrEyXMgRIbkrOE4D9K+Hx6rpFzKznnEmZVDkRgwUiZ498krzOCkuQ///yzvWvXrj8zSHK2YjI+QlOPzlMb7sbM6dOnnzl48GAE/UrzfTiEZWRaDZbhZt/33gv5Mm/ercEpUly0uTkBh66AQUp9VhjrGybdDuLZfzAR0ozkSFA+SeP2VkSRy3HOba8nCX2jq2ikJKhBQVh9A6zhqVLJd2DCVyNQYErILPTtlixZopOTaRzOrezYsaOeG2UelCkd5h979Ojh1MTTL1y7du0DEHgl00zGtjleFU7DA1FrQNNPQoD0y7p16/5m6oxuCDuIQ+PTSuzcufPBpEmT/gChA+qVLt0xKHXq4Tbl28e5+QVJSau0A/VKy7QOWOkiKZMrQbmI6w9gPfynKTArS2HC7zpMeFR8LtQelvhccgMsmHt9D8upMG29QLwxgwbp6RizUOMwyQ0TrWtLBkucgJExY0bp6+urjyxRu44ePVoPUMzCRP3y5ctvv/XWW7Nr1KhRQiTQODU1c86cOctWrFixZ/v27Zf7+/sfh9m/FRgYGBEUFBQ5f/78u+PGjTvXrVu3LS+99NJnxYoVq109Q4YcsDjvaur5TDES1NCWtEwSJpx72NuXAfAx6TpFI2BcSJIENaJ4PuyKFfmnTT0vaBqOXXGsuV6IoiBfV5DzRlRSQovqG6uSlNyw1ryHJR+UMBRasHujRvLIwYPRzDyFmpUmnWPxIIKuNTmSRNC8M/8IraWnbMzCoU4u523cuPEX5cqVy2sul5clBTpONmj0qiBgZxBxBDT91DZt2kxDgPYl/r9X7ty5G+BzDrnqmjxcPYWE+wuYCcoZY3y0zXFozIOo3wuwTg9ASv0BE2bSuQMokn/wW/NWJ6Uonk8qRmX9ACwEKQfuE6I+zE1+x/PL/YVI+6UQLUDQ8zTtY8TDDft1Us4RD/dG/w/43oQUKWT3okXl3OnTY0xqUxPCl9ST34zcGRgxemcOdNq0afrCNPNoFH/n6NGjkSNGjPiFW9XkzZs3m7lcCSTU0mnQebKkS5cuL5Afmp8TVThIkDLqhSaC6pvYauqhEHyMzhTU8Xsg50AQc+cCtVtdtDp0BSQ1yQ1i0l+9ESzE5C1J6VE0KEyqcPVol1LcUMBcMH98Ph6fTxTiyBQ4/NxYldpxnpPKMmMWzPxQmO0+rVvrk3adRcIkG5PeBw4ckPPmzdPHtzkOv3LlSnn27Fmn36H/t3Xr1rvvv//+BkT78UnSJ4hItYS7A8i4l6QEIfdoaji5D95/Ga8LQ3tmRbDZGvW0fYEHBHWQkpsGM5gKEfow80UQ/zP+trkdk6ywoNCWBUHKLfNi3h7QDG4V+Be06PGxvr6bWlasuO3bqVNvcD2RMy1K4fs0+UzKcyiUQ5nOruV7Fy9eJJkvNWvWbApXd3JXOvN9P04BEX1BlEbo+CNx/gkI+TqfZMdhZZKX18BCZYK/2HOR2uOTKSNzHUYDrpXwUfXnLXGP/20i2vOlzuJ8wNnkNqmEIxeoxDmopPvmSjOBBObGqtuACSDo22NSpapdrVix9m+2b79j48aN95z5k+4Izf2+ffsiBw8evJ/7HRnm/YnSFhyOBEFzwV16htqM0+TMGg3XZEdQM3Sh2rI7xkidJhyaVn8IGncP5L6rnJWPIMzZ6NT/0Cnep1WM+l9JXrhBKipq4ALnpkgnJci4C8fpQHec10XlF+SzelqjsUqUKJEHpnhAv379Tuzfvz8itnmesQm1JyP6BQsWXG/RosUc+KyV4rPc43EKTPQzqKNJqKur5jp1kBKKQULT6k9DCRVxPz0Z5NyPjtHGoaWTjXDDK5j311FxN4xKpAm/ico9iuNiHAcCjeEGFHYEV6af8C1QoECp2rVrfz1y5MiLR44ciYxrxrwzYe4Tvuf9Pn367KpSpUrHkiVLPnHa01WBea8Bgq5End52kNJhwvl4SD6eh35lXKQ0IQSata5/ciMoTQYqswr9JfTsc6jQn0DIESBtK1RsWZirrAFOzFhUYdKb+3zWqVNn/ueff34FJLW7Q1JeC+0bOWzYsN/r1q07EuQsLhKpKaMLAA3aFnWqAffxWt+VmrlQ+pVwC/TEvRvEdGAlg93Y2iFJCU0FCp0ZFVUhTIi+MDXHETFuCYS2RKXm8ndzH3lG29wgoWbNmt8NGTLkXEhIiL72x1kw5BB+Rr+Vm4d99tlnZ0DOKXzqGwlv/v3EIqjDbCuF+BjBzu/wKyOhAPSnocTgV7qEcPX47plJfi8nFo5rsJkL5f6VKLi/Te1fyWG7WzgPRS99jlrA/F1XhCMzuXPnrozIe8w777xzaPbs2Xc4okQSMplPQjpArckFaatWrbrft2/f32vUqDEZQVG1hNoj9FEJNGRJ+JRTEexc4hwHT0lpwhW012fMFJj/L0mINCJP5uk09Zz0pSCnhuOfRu9kspk4gdevafHb/TcNtzuEye9Uv379BT179jw+ceLEf5YvXx7JteicpYSIX9+vHpr2YsuWLTeUL1/+I5CznDFzPtGSkx0bpGyoqac4cyKymWie4iiI/i5jAPN/JloxKisbClYFpOsKfAeEaGocnuPxzjZyuI5rhm+J/76VKbild/r06cvDXL+NoGd8kyZN1rRu3XrvG2+8cQhReijMOTdm+MjPz+8lXJdLJFKfM6poau5D33A1/8G8ca2n4O9spnLx1LI9UcJCoEBFbOpZSGNx/FlTOTSa8Lgq7S6u+5HEFt7RZCm58ULatGkLZsqU6fkcOXLUhwvQCBq2NghcyhhK5Pi2N/7rsQrdJ5Co3B61u/INJ3XrKe6Eq60zE+9z4nHzvgeFKEzzTF8FRPwROBSudlDjnEVn2tIZIm3KnLzo5YQwK9YZkoyg7jIDXYBwTblN5rr1FGzDEUDmRElQaLtyIGV/kGq+4VdyOxWHT2kurCu4DC0wlDOhzP9lSczCbAgwW/u3/s316ikOAe2ldxXGoxNNbe19hiZc807FcBHXBm4LmOxGLTwURteo//c0NcPJK7u4GHiA310FBVQ50bYFfU3NS5vTGiDJz0Azd/FCsJTkhRmScLVB28JwtQeWN5SEA5dBzi+YgUmU5p2CQpRFxfzmpHDxAfdQX8wJEf6Jtec+IkFd5QY+0VxcAuIOwpVGbn8yMSsKTTnnK8yFiyciDdJ3Srabq7ogTYXIOF6ItquF2LxTPSDNm9qTa8aWoR2e9U/MSgIF8QW6s0BOChkf8Mloqw8IUcg/MVdQAgl9whVCVBsixIK+MMXfoFNzZhLH2Z3UpSfgnk2fJvrRI39U1A5EkOhpJ50UMj6w4zf/AD4wIvrE6QMlgNAfPCREfmhN/x+EONEZyqEx3h4q1Cx4jrs7qU93QFdhM9Ag0UbvUcSHE2dRmHmad00McQ9mJgyOej0tfsOfSUpQH3k09cjD8BAh7n6OuqoClAI6CLWWi3M8ndSnS0CdXwa+3C9E3kQbHEWV70Ae9NrWNu+O/zrAUZGZNPWJNtXhReEoG6zK28A2TQWT+oz5JkBmIDvQQKil2lxPZIten3GBE0x2AE2TjP/PXgYtmldToxjmAscXHIn6fY+KVDOb/9ssJPFPQuRaJUQN+GjlktIEhzAERSBOK5BzXbiat6DvLMJJyG8BOYGCQF3gI6EWvnFSspM6jQ181ueknUktg0IioMIGad4dZnOAyee9zLkaTvt/zA5zgRuEyIEGqb1UiI8WC7EECAOWBgjRhIvIErupMibetEM9rAGuOshJkKDvCqU5PxVqZSzXGW0VbgdN/M0woNmOpLY4jpprvxpu4yMPzQX3Bug+rMfv1zOWfqTguvslQjwLEr4LMk5DwBC2UIjTwN/AA+A6Pv9pGdyPgEQ6lsx7hs+ZHWXvBGwAMa9FJSdNOMqtE7Q/sFKo1Zgkpgfm/TJ+eyy+m98/KWlPh9AEoZBDnBTcG2AAdh2VvgqBQTuY7zdBvvFonM0g4vGFalc2rgyNuoqR27z8BfKGQLN24+ar/omo4tkJUd7CKHc/HLfjeDMqOQma8PFAV+Ab4XlwhN+/DwTj9xslGd/TLKxQFLas5oVNa6OCmoCzw9EB7BtB0kAhDhhrvq9QUxpEjG157T+4fj9I6p9Y/NItQqRFmauh/F8Bh2wqLxwtS8LcJ816P6FWasYjxcTJ4gMT9bCmK2Jo0dGaF3xREnOnSkBHIvCJhI/J7RkjFylSRsRGSjNw7T1o21P4/nw0ZKOFT7BfelT5my1BmMWohzPav6sOotURyqOb9rFCkdUDs05wzudioJKW1NN51KLohaXD1dQ7c0XECYOU3JUtEpougqSE5rNz2SxIFY147gC/EQF/9No6mHy4CQPwX2W48YG5DI9D2FmMPf1r4r7G2NSWNpz8EeMIXahQ6SRu6os68nS3Zc5Y2g604f8/qZ3Wq8IIEAX+QFNT8MwV4gycqHwPpIlcD8BXtAcoUrqsIWMCSQ0fVI9q8duMbO24vzvoRCfwn0sQgHTEsTD9rsfROPxPlDWdpibdfKipp6JwWUyMWtMBdF45RKgN1+KhPamhh8GXzeefiPzzeInhixYBVjqpkKigw8+Fc2vhGkwFiU6DlJGMSs1Ecxf8DTYgd8+AP/dwSxdHdGtTmomPYDkKLML7nXFNkUepUQ8IkR7EqIR76Yt7CAL+p6lJH3HunMyyTAYGC2XmPdSef+G/F6Dszwc8wnI/EWLkReuiEi6YKoXEuIjPtuI4GsdXocXKwccsDjM1EMS6sMBDzUlSwoQ/3JUtVKgoN6ZcIP6boyactcP5rMdw/BHXDuF9c5jP21qVv0VScjK2pp5hyge5csz7lOYiMQl2MJbzM6Eid+6p5IH25Hj7RnyvMeMGb5Yz0YimVhmO1dSQHPOYXG80HcdOnKWNY25Gq6iclOjBKaEJigBTGHWbyRcTaMKpQbh7Brd02SY83j2D5GCkzFk8u3HfCzU1etWA81LZiNSuvE/hQmOywVG2VCQ5jk+jvKWAVpp6NCS1JXdI5nofriBwiZgO0CIwKBotVJLeg8idSuLgXvUcVT//5GLazULiQRMVRyV8jkrsBsJUgRktyNlJ+CyVudfSzASCuNCkaxY430zsISkZNDGtQr/SQUqHCXfSIO6Afh9Hrmj+zwGHbUrbc8b6KDRqdxxb4FgPx6r4z3L477IELQE0ZFW83wjXt6fpxvkEYDle79TUbtO0KOysjs1nzf8fK2gRuA36cKF2nQ5zco0L4CrbQex4RodLvsKJJHvUdoFPk7AGKWPUQLj+KVRafWjFkIVRtmR0BDuB4l+/ko1DUrqpKZ2CvxH1t2j+ceSUP2o3EvYWzi/heFpTfus+YKdNTdrYQuDzbcBO4IBN+ZN/2NTYtk5I47fcJqUD7HyM1kcAU4SyGB50SN4TR4tKa0k9peSqkJRmbRmbMEcZKEQb+JQHcR5BE86NVV3xKz0BAyiSn5opjmhYJ62mTCQ14P1wtZZfh6Yib47I8HMHGT0mpBm0FiOF2sefQ5qsB/M1sSFcpa2+R909f1K5Vi63iSVRhBWHiP5poNkGaKoQkIFRqre0ZVSQnNwTvwnQEYD29sSnS3DQalBzclIy75EujZt1weXIM+iW4PiURc74C4OMp7er/diZ9PfmctqHYMN3A/IAlYUa16aWNl/3uEBLwXtkxD5AKL+T9+cmOelPM5VWh1kEi5xeEn9ElyCpHyq2rU09wsbrJA0EWgAZgSxAK6HMvbvmMyFAci4Xam5nb2CWUAGhO+QMVzOUZiOAq51s00kJKVKRlGmaV1DhmzSVCorWEJ5imVCkLC/UpF9OvPhSqJwq84ve9HVdBQlIIjIQ6gR0F4qcW43PzNfHgnMg5xSadUtzJqCwYjlOvEelb4LCVVLb3BgegeaTft3HQmlTBmIMyOYINVIzT6inXjwKjUry0bdkp+EEkKZCuR9zhXua08gWnEWn/grfqcChZ4ucCSysYE5QZgSKyp+mqSR3vCNkEo+RO4nJc5KAR/p5HJHi4xeHCxU5zzWuTQitypQZXQua8/pCzY7nMCZzvQzkXCUn8MCmUmD9EewV9/ZomCVxCCscGuJZNMJgNMIRNoiTRnILbHxnBCBRtwqV0mGkzzmX7wpFImrXQKGITQK5Q1pHJ6ALQW05VqjVmNWEWp3Jc5r3DcZ15u/HAHbWv1A3a3Fsz6FazcpzPh5h8h+VnxuN8Wa4Cp7iPfc0JpBMTDuFCKVR8d86QV8H6giVnuos1JS3r4UaVHA8tIAEhP+sa10+h4gBD31JDlH2FOo3Kgm10K040Mz4jDOvqMHdIT3q4U+Y9O9xv/V2qAdPJO8RosctDJ44ZIrGeQGYpKkpam6NabsLEobakoQjCWcAnwCtgZpAGaAI8AxQyDgvahz5mkTMC+QSKq1VEngZ6CWUK8FxdXYEN/Owd0DK3Tj2wbHEWcvffKLEhxM40KCF0EBdwtWwI2cmxds3jQ3UqiQrAxpqSQZVDKYmCJUF6CJU6qoeUAN4AahuvGbGgIGPv1CkDBTKTXBMcDH/VyzgLCzO5fweaILOmnNLEtgFJEkKNEZKjvXb1H74o4DfbF7wTV2Bg6wc6WKgw2ibGpYmnhkCugXET8Zrvs/PqSkdE1yc+b9xgIn3TZyAw0DISCElzxlJiUVo1tBovtAiuXBsEK6m9XHCxiMhalQ4gq7YYP6OC+Dc1Rs2NbOqP8pXiU+QtrRmIhNqkpNCpEUjFkAjNrepPaNoCr0+CvWIQHflb5RjB8ozCBqzGkjpR9fG8jUTsZCoTFDDN8tnJPgZSHFTCc46MpPgiYRNTfDYCPSjxvwlhqcbW5KIhUTdojRqbvip1feqTRDWAWfx3r3wBA6o3ATNONcJ8cEFnBb31n4hStOU47WvRcwkLCQqtU+wEJmhVYuBBK+DnF+i4XeRFCSHE8I8KtBPphuyAvf0Ie6nBrR/XgY/9DEtYiYv4TLflPRTQ5VmKqCptehc8rsQR5umZs4nlM/KjsC5BFz2zK1muHCOW1eWgcbMxRlH7Ej+VlRuCUSf6Q+C+JIYMP95QJjnNLVQ7j1OtsD5auCAppZ6kLjXDYJxVhVHsByDAzTP1IT0cRnUUCtfCVfrmvhowjCbepbUIJvapa4mzovSr2Rnkf8uh7HEEudCgpAo1GCcmMLcKkiaHa8LcEFcuFpGTW33Ls577lXpnuGaWj49EsdPgT571QJBTrRuArxgLDPOjQg8G2dlMXjTlE+ZwiKlJfEVXcs6iEttB3I9RcA/zEDNyyFXguf0G/kZSWjMJKIP6SCiRUZLLLHEEkssscQSSyyxxBJLLLHEEkssscQSSyyxxBJLLLHEEkssscQSSyyxxBJLLLHEEkssscQSSyyxxBJLLLHEEkssscQSSyyxxBJLLElC8n8e1s+VVx8BUQAAAABJRU5ErkJggg==", + "mediatype": "image/png" + } +} +{ + "schema": "olm.channel", + "name": "alpha", + "package": "node-observability-operator", + "entries": [ + { + "name": "node-observability-operator.v0.1.0" + } + ] +} +{ + "schema": "olm.bundle", + "name": "node-observability-operator.v0.1.0", + "package": "node-observability-operator", + "image": "registry.redhat.io/noo/node-observability-operator-bundle-rhel8@sha256:25b8e1c8ed635364d4dcba7814ad504570b1c6053d287ab7e26c8d6a97ae3f6a", + "properties": [ + { + "type": "olm.gvk", + "value": { + "group": "nodeobservability.olm.openshift.io", + "kind": "NodeObservability", + "version": "v1alpha1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "nodeobservability.olm.openshift.io", + "kind": "NodeObservabilityMachineConfig", + "version": "v1alpha1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "nodeobservability.olm.openshift.io", + "kind": "NodeObservabilityRun", + "version": "v1alpha1" + } + }, + { + "type": "olm.package", + "value": { + "packageName": "node-observability-operator", + "version": "0.1.0" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm1ldGFkYXRhIjp7Im5hbWUiOiJwcm94eS1yb2xlIn0sInJ1bGVzIjpbeyJhcGlHcm91cHMiOlsiYXV0aGVudGljYXRpb24uazhzLmlvIl0sInJlc291cmNlcyI6WyJ0b2tlbnJldmlld3MiXSwidmVyYnMiOlsiY3JlYXRlIl19LHsiYXBpR3JvdXBzIjpbImF1dGhvcml6YXRpb24uazhzLmlvIl0sInJlc291cmNlcyI6WyJzdWJqZWN0YWNjZXNzcmV2aWV3cyJdLCJ2ZXJicyI6WyJjcmVhdGUiXX1dfQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZUJpbmRpbmciLCJtZXRhZGF0YSI6eyJuYW1lIjoicHJveHktcm9sZWJpbmRpbmcifSwicm9sZVJlZiI6eyJhcGlHcm91cCI6InJiYWMuYXV0aG9yaXphdGlvbi5rOHMuaW8iLCJraW5kIjoiQ2x1c3RlclJvbGUiLCJuYW1lIjoicHJveHktcm9sZSJ9LCJzdWJqZWN0cyI6W3sia2luZCI6IlNlcnZpY2VBY2NvdW50IiwibmFtZSI6ImNvbnRyb2xsZXItbWFuYWdlciIsIm5hbWVzcGFjZSI6InN5c3RlbSJ9XX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJraW5kIjoiU2VydmljZSIsIm1ldGFkYXRhIjp7ImxhYmVscyI6eyJjb250cm9sLXBsYW5lIjoiY29udHJvbGxlci1tYW5hZ2VyIn0sIm5hbWUiOiJjb250cm9sbGVyLW1hbmFnZXItbWV0cmljcy1zZXJ2aWNlIn0sInNwZWMiOnsicG9ydHMiOlt7Im5hbWUiOiJodHRwcyIsInBvcnQiOjg0NDMsInByb3RvY29sIjoiVENQIiwidGFyZ2V0UG9ydCI6Imh0dHBzIn1dLCJzZWxlY3RvciI6eyJjb250cm9sLXBsYW5lIjoiY29udHJvbGxlci1tYW5hZ2VyIn19fQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJraW5kIjoiU2VydmljZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJsYWJlbHMiOnsiY29udHJvbC1wbGFuZSI6ImNvbnRyb2xsZXItbWFuYWdlciJ9LCJuYW1lIjoibm9kZS1vYnNlcnZhYmlsaXR5LW9wZXJhdG9yLWNvbnRyb2xsZXItbWFuYWdlci1tZXRyaWNzLXNlcnZpY2UifSwic3BlYyI6eyJwb3J0cyI6W3sibmFtZSI6Imh0dHBzIiwicG9ydCI6ODQ0MywicHJvdG9jb2wiOiJUQ1AiLCJ0YXJnZXRQb3J0IjoiaHR0cHMifV0sInNlbGVjdG9yIjp7ImNvbnRyb2wtcGxhbmUiOiJjb250cm9sbGVyLW1hbmFnZXIifX0sInN0YXR1cyI6eyJsb2FkQmFsYW5jZXIiOnt9fX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJkYXRhIjp7ImNvbnRyb2xsZXJfbWFuYWdlcl9jb25maWcueWFtbCI6ImFwaVZlcnNpb246IGNvbnRyb2xsZXItcnVudGltZS5zaWdzLms4cy5pby92MWFscGhhMVxua2luZDogQ29udHJvbGxlck1hbmFnZXJDb25maWdcbmhlYWx0aDpcbiAgaGVhbHRoUHJvYmVCaW5kQWRkcmVzczogOjgwODFcbm1ldHJpY3M6XG4gIGJpbmRBZGRyZXNzOiAxMjcuMC4wLjE6ODA4MFxud2ViaG9vazpcbiAgcG9ydDogOTQ0M1xubGVhZGVyRWxlY3Rpb246XG4gIGxlYWRlckVsZWN0OiB0cnVlXG4gIHJlc291cmNlTmFtZTogOTRjNzM1YjYub2xtLm9wZW5zaGlmdC5pb1xuIn0sImtpbmQiOiJDb25maWdNYXAiLCJtZXRhZGF0YSI6eyJuYW1lIjoibm9kZS1vYnNlcnZhYmlsaXR5LW9wZXJhdG9yLW1hbmFnZXItY29uZmlnIn19" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJSb2xlIiwibWV0YWRhdGEiOnsiY3JlYXRpb25UaW1lc3RhbXAiOm51bGwsIm5hbWUiOiJub2RlLW9ic2VydmFiaWxpdHktb3BlcmF0b3ItbWFuYWdlci1yb2xlIn0sInJ1bGVzIjpbeyJhcGlHcm91cHMiOlsiYXBwcyJdLCJyZXNvdXJjZXMiOlsiZGFlbW9uc2V0cyJdLCJ2ZXJicyI6WyJjcmVhdGUiLCJnZXQiLCJsaXN0Iiwid2F0Y2giXX0seyJhcGlHcm91cHMiOlsiIl0sInJlc291cmNlcyI6WyJjb25maWdtYXBzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ1cGRhdGUiLCJ3YXRjaCJdfSx7ImFwaUdyb3VwcyI6WyIiXSwicmVzb3VyY2VzIjpbInNlY3JldHMiXSwidmVyYnMiOlsiY3JlYXRlIiwiZGVsZXRlIiwiZ2V0IiwibGlzdCIsIndhdGNoIl19LHsiYXBpR3JvdXBzIjpbIiJdLCJyZXNvdXJjZXMiOlsic2VydmljZWFjY291bnRzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ3YXRjaCJdfSx7ImFwaUdyb3VwcyI6WyIiXSwicmVzb3VyY2VzIjpbInNlcnZpY2VzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ3YXRjaCJdfSx7ImFwaUdyb3VwcyI6WyJyYmFjLmF1dGhvcml6YXRpb24uazhzLmlvIl0sInJlc291cmNlcyI6WyJyb2xlYmluZGluZ3MiXSwidmVyYnMiOlsiY3JlYXRlIiwiZGVsZXRlIiwiZ2V0IiwibGlzdCIsIndhdGNoIl19LHsiYXBpR3JvdXBzIjpbInJiYWMuYXV0aG9yaXphdGlvbi5rOHMuaW8iXSwicmVzb3VyY2VzIjpbInJvbGVzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ3YXRjaCJdfV19" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJuYW1lIjoibm9kZS1vYnNlcnZhYmlsaXR5LW9wZXJhdG9yLW1ldHJpY3MtcmVhZGVyIn0sInJ1bGVzIjpbeyJub25SZXNvdXJjZVVSTHMiOlsiL21ldHJpY3MiXSwidmVyYnMiOlsiZ2V0Il19XX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"annotations":{"alm-examples":"[\n  {\n    \"apiVersion\": \"nodeobservability.olm.openshift.io/v1alpha1\",\n    \"kind\": \"NodeObservability\",\n    \"metadata\": {\n      \"name\": \"cluster\"\n    },\n    \"spec\": {\n      \"labels\": {\n        \"node-role.kubernetes.io/worker\": \"\"\n      },\n      \"type\": \"crio-kubelet\"\n    }\n  },\n  {\n    \"apiVersion\": \"nodeobservability.olm.openshift.io/v1alpha1\",\n    \"kind\": \"NodeObservabilityMachineConfig\",\n    \"metadata\": {\n      \"name\": \"sample\"\n    },\n    \"spec\": {\n      \"debug\": {\n        \"enableCrioProfiling\": true\n      }\n    }\n  },\n  {\n    \"apiVersion\": \"nodeobservability.olm.openshift.io/v1alpha1\",\n    \"kind\": \"NodeObservabilityRun\",\n    \"metadata\": {\n      \"name\": \"nodeobservabilityrun-sample\",\n      \"namespace\": \"node-observability-operator\"\n    },\n    \"spec\": {\n      \"nodeObservabilityRef\": {\n        \"name\": \"cluster\"\n      }\n    }\n  }\n]","capabilities":"Basic Install","containerImage":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","createdAt":"2022-07-08T22:30:53","operatorframework.io/suggested-namespace":"node-observability-operator","operators.openshift.io/valid-subscription":"[\"OpenShift Container Platform\"]","operators.operatorframework.io/builder":"operator-sdk-v1.18.0+git","operators.operatorframework.io/project_layout":"go.kubebuilder.io/v3"},"name":"node-observability-operator.v0.1.0","namespace":"placeholder"},"spec":{"apiservicedefinitions":{},"customresourcedefinitions":{"owned":[{"description":"NodeObservability prepares a subset of worker nodes (identified by a label) for running node observability queries, such as profiling","displayName":"Node Observability","kind":"NodeObservability","name":"nodeobservabilities.nodeobservability.olm.openshift.io","version":"v1alpha1"},{"description":"NodeObservabilityMachineConfig is the Schema for the nodeobservabilitymachineconfigs API","displayName":"Node Observability Machine Config","kind":"NodeObservabilityMachineConfig","name":"nodeobservabilitymachineconfigs.nodeobservability.olm.openshift.io","version":"v1alpha1"},{"description":"NodeObservabilityRun is a request to run observability actions on the nodes previously selected in NodeObservability resource","displayName":"Node Observability Run","kind":"NodeObservabilityRun","name":"nodeobservabilityruns.nodeobservability.olm.openshift.io","version":"v1alpha1"}]},"description":"An Operator that will be able to gather debugging/profiling data over\na custom period of time which would be helpful to troubleshoot and resolve issues\nfor OpenShift customers.","displayName":"Node Observability Operator","icon":[{"base64data":"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","mediatype":"image/png"}],"install":{"spec":{"clusterPermissions":[{"rules":[{"nonResourceURLs":["/debug/*"],"verbs":["get"]},{"nonResourceURLs":["/node-observability-pprof"],"verbs":["get"]},{"nonResourceURLs":["/node-observability-status"],"verbs":["get"]},{"apiGroups":[""],"resources":["endpoints"],"verbs":["get","list","watch"]},{"apiGroups":[""],"resources":["events"],"verbs":["create"]},{"apiGroups":["authentication.k8s.io"],"resources":["tokenreviews"],"verbs":["create"]},{"apiGroups":["authorization.k8s.io"],"resources":["subjectaccessreviews"],"verbs":["create"]},{"apiGroups":[""],"resourceNames":["kubelet-serving-ca"],"resources":["configmaps"],"verbs":["get","list"]},{"apiGroups":[""],"resources":["nodes"],"verbs":["get","list","patch","watch"]},{"apiGroups":[""],"resources":["nodes/proxy"],"verbs":["get","list"]},{"apiGroups":[""],"resources":["pods"],"verbs":["get","list","watch"]},{"apiGroups":["machineconfiguration.openshift.io"],"resources":["machineconfigpools"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["machineconfiguration.openshift.io"],"resources":["machineconfigs"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilities"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilities/finalizers"],"verbs":["update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilities/status"],"verbs":["get","patch","update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilitymachineconfigs"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilitymachineconfigs/finalizers"],"verbs":["update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilitymachineconfigs/status"],"verbs":["get","patch","update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilityruns"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilityruns/finalizers"],"verbs":["update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilityruns/status"],"verbs":["get","patch","update"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["clusterrolebindings"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["clusterroles"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["security.openshift.io"],"resources":["securitycontextconstraints"],"verbs":["create","delete","get","list","use","watch"]},{"apiGroups":["authentication.k8s.io"],"resources":["tokenreviews"],"verbs":["create"]},{"apiGroups":["authorization.k8s.io"],"resources":["subjectaccessreviews"],"verbs":["create"]}],"serviceAccountName":"node-observability-operator-controller-manager"}],"deployments":[{"label":{"control-plane":"controller-manager"},"name":"node-observability-operator-controller-manager","spec":{"replicas":1,"selector":{"matchLabels":{"control-plane":"controller-manager"}},"strategy":{},"template":{"metadata":{"annotations":{"kubectl.kubernetes.io/default-container":"manager"},"labels":{"control-plane":"controller-manager"}},"spec":{"containers":[{"args":["--secure-listen-address=0.0.0.0:8443","--upstream=http://127.0.0.1:8080/","--logtostderr=true","--v=10"],"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e","name":"kube-rbac-proxy","ports":[{"containerPort":8443,"name":"https","protocol":"TCP"}],"resources":{"limits":{"cpu":"20m","memory":"40Mi"},"requests":{"cpu":"10m","memory":"20Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]},"seccompProfile":{"type":"RuntimeDefault"}}},{"args":["--health-probe-bind-address=:8081","--metrics-bind-address=127.0.0.1:8080","--leader-elect","--zap-log-level=$(LOG_LEVEL)","--operator-namespace=$(OPERATOR_NAMESPACE)","--agent-image=$(RELATED_IMAGE_AGENT)"],"env":[{"name":"LOG_LEVEL","value":"info"},{"name":"OPERATOR_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.namespace"}}},{"name":"RELATED_IMAGE_AGENT","value":"registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc"}],"image":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","imagePullPolicy":"Always","livenessProbe":{"httpGet":{"path":"/healthz","port":8081},"initialDelaySeconds":15,"periodSeconds":20},"name":"manager","readinessProbe":{"httpGet":{"path":"/readyz","port":8081},"initialDelaySeconds":5,"periodSeconds":10},"resources":{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"10m","memory":"64Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]},"seccompProfile":{"type":"RuntimeDefault"}},"volumeMounts":[{"mountPath":"/var/run/secrets/openshift.io/certs","name":"ca-bundle"}]}],"securityContext":{"runAsNonRoot":true},"serviceAccountName":"node-observability-operator-controller-manager","terminationGracePeriodSeconds":10,"volumes":[{"configMap":{"items":[{"key":"service-ca.crt","path":"service-ca.crt"}],"name":"openshift-service-ca.crt"},"name":"ca-bundle"}]}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["configmaps"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":["coordination.k8s.io"],"resources":["leases"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":[""],"resources":["events"],"verbs":["create","patch"]},{"apiGroups":["apps"],"resources":["daemonsets"],"verbs":["create","get","list","watch"]},{"apiGroups":[""],"resources":["configmaps"],"verbs":["create","delete","get","list","update","watch"]},{"apiGroups":[""],"resources":["secrets"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":[""],"resources":["serviceaccounts"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":[""],"resources":["services"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["rolebindings"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["roles"],"verbs":["create","delete","get","list","watch"]}],"serviceAccountName":"node-observability-operator-controller-manager"}]},"strategy":"deployment"},"installModes":[{"supported":true,"type":"OwnNamespace"},{"supported":false,"type":"SingleNamespace"},{"supported":false,"type":"MultiNamespace"},{"supported":false,"type":"AllNamespaces"}],"keywords":["node-observability-operator"],"links":[{"name":"Source Code","url":"https://github.com/openshift/node-observability-operator"}],"maturity":"alpha","minKubeVersion":"1.23.0","provider":{"name":"Red Hat, Inc."},"relatedImages":[{"image":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","name":"node-observability-rhel8-operator-0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19-annotation"},{"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e","name":"kube-rbac-proxy"},{"image":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","name":"manager"},{"image":"registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc","name":"agent"}],"version":"0.1.0"}}" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZUJpbmRpbmciLCJtZXRhZGF0YSI6eyJuYW1lIjoibWFuYWdlci1yb2xlYmluZGluZyJ9LCJyb2xlUmVmIjp7ImFwaUdyb3VwIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pbyIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm5hbWUiOiJtYW5hZ2VyLXJvbGUifSwic3ViamVjdHMiOlt7ImtpbmQiOiJTZXJ2aWNlQWNjb3VudCIsIm5hbWUiOiJjb250cm9sbGVyLW1hbmFnZXIiLCJuYW1lc3BhY2UiOiJzeXN0ZW0ifV19" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"apiextensions.k8s.io/v1","kind":"CustomResourceDefinition","metadata":{"annotations":{"controller-gen.kubebuilder.io/version":"v0.8.0"},"creationTimestamp":null,"name":"nodeobservabilityruns.nodeobservability.olm.openshift.io"},"spec":{"group":"nodeobservability.olm.openshift.io","names":{"kind":"NodeObservabilityRun","listKind":"NodeObservabilityRunList","plural":"nodeobservabilityruns","shortNames":["nobr"],"singular":"nodeobservabilityrun"},"scope":"Namespaced","versions":[{"additionalPrinterColumns":[{"jsonPath":".spec.nodeObservabilityRef.name","name":"NodeObservabilityRef","type":"string"}],"name":"v1alpha1","schema":{"openAPIV3Schema":{"description":"NodeObservabilityRun is a request to run observability actions on the nodes previously selected in NodeObservability resource","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"NodeObservabilityRunSpec defines the desired state of NodeObservabilityRun","properties":{"nodeObservabilityRef":{"description":"NodeObservabilityRef is the reference to the parent NodeObservability resource","properties":{"name":{"description":"Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"}},"required":["name"],"type":"object"}},"required":["nodeObservabilityRef"],"type":"object"},"status":{"description":"NodeObservabilityRunStatus defines the observed state of NodeObservabilityRun","properties":{"agents":{"description":"Agents represents the list of Nodes that are included in this Run. Agents are Pods, and as such, not all are always ready/available","items":{"properties":{"ip":{"type":"string"},"name":{"type":"string"},"port":{"format":"int32","type":"integer"}},"type":"object"},"type":"array"},"conditions":{"description":"Conditions contain details for aspects of the current state of this API Resource.","properties":{"conditions":{"items":{"description":"Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions.  For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }","properties":{"lastTransitionTime":{"description":"lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.","format":"date-time","type":"string"},"message":{"description":"message is a human readable message indicating details about the transition. This may be an empty string.","maxLength":32768,"type":"string"},"observedGeneration":{"description":"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.","format":"int64","minimum":0,"type":"integer"},"reason":{"description":"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.","maxLength":1024,"minLength":1,"pattern":"^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$","type":"string"},"status":{"description":"status of the condition, one of True, False, Unknown.","enum":["True","False","Unknown"],"type":"string"},"type":{"description":"type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)","maxLength":316,"pattern":"^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$","type":"string"}},"required":["lastTransitionTime","message","reason","status","type"],"type":"object"},"type":"array"}},"type":"object"},"failedAgents":{"description":"FailedAgents represents the list of Nodes that could not be included in this Run This could be due to Node/Pod/Network failure","items":{"properties":{"ip":{"type":"string"},"name":{"type":"string"},"port":{"format":"int32","type":"integer"}},"type":"object"},"type":"array"},"finishedTimestamp":{"description":"FinishedTimestamp represents the server time when the NodeObservabilityRun finished. When not set, the NodeObservabilityRun isn't known to have finished. It is represented in RFC3339 form and is in UTC.","format":"date-time","type":"string"},"output":{"description":"Output is the output location of this NodeObservabilityRun When not set, no output location is known","type":"string"},"startTimestamp":{"description":"StartTimestamp represents the server time when the NodeObservabilityRun started. When not set, the NodeObservabilityRun hasn't started. It is represented in RFC3339 form and is in UTC.","format":"date-time","type":"string"}},"type":"object"}},"type":"object"}},"served":true,"storage":true,"subresources":{"status":{}}}]},"status":{"acceptedNames":{"kind":"","plural":""},"conditions":[],"storedVersions":[]}}" + } + } + ], + "relatedImages": [ + { + "name": "agent", + "image": "registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc" + }, + { + "name": "", + "image": "registry.redhat.io/noo/node-observability-operator-bundle-rhel8@sha256:25b8e1c8ed635364d4dcba7814ad504570b1c6053d287ab7e26c8d6a97ae3f6a" + }, + { + "name": "node-observability-rhel8-operator-0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19-annotation", + "image": "registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19" + }, + { + "name": "manager", + "image": "registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19" + }, + { + "name": "kube-rbac-proxy", + "image": "registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e" + } + ] +} diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/grpc_health_probe b/pkg/cli/mirror/testdata/manifestlist/testonly/grpc_health_probe new file mode 100755 index 000000000..e69de29bb diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac new file mode 100644 index 000000000..6dd57b335 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac @@ -0,0 +1,16 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "schemaVersion": 2, + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "digest": "sha256:9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66", + "size": 1168 + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "digest": "sha256:da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e", + "size": 78717 + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29 b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29 new file mode 100644 index 000000000..b93908c93 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29 @@ -0,0 +1 @@ +{"architecture":"ppc64le","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-10T20:56:22.923857404Z","history":[{"created":"2023-03-10T20:56:22.923857404Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"moby.buildkit.buildinfo.v1":"eyJmcm9udGVuZCI6ImRvY2tlcmZpbGUudjAifQ==","os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:49a0b15145b6415d136ba894bd24d77efc211c25e5d46c81ee5669920af19658"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790 b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790 new file mode 100644 index 000000000..2e14dd082 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790 @@ -0,0 +1,16 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "schemaVersion": 2, + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "digest": "sha256:242f90086130a4078a57cf948c7c11e628fed90f911a44ae24779c6b7fc61d29", + "size": 1170 + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "digest": "sha256:da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e", + "size": 78717 + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58 b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58 new file mode 100644 index 000000000..329f4809c --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58 @@ -0,0 +1,16 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "schemaVersion": 2, + "config": { + "mediaType": "application/vnd.docker.container.image.v1+json", + "digest": "sha256:d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a", + "size": 1168 + }, + "layers": [ + { + "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip", + "digest": "sha256:da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e", + "size": 78717 + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66 b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66 new file mode 100644 index 000000000..756c209b8 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/9f80ea8b27f730ec3629da1f5c2065305da64af1d9e0cc8f5511f7d1ed234a66 @@ -0,0 +1 @@ +{"architecture":"s390x","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-10T20:56:22.923857404Z","history":[{"created":"2023-03-10T20:56:22.923857404Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"moby.buildkit.buildinfo.v1":"eyJmcm9udGVuZCI6ImRvY2tlcmZpbGUudjAifQ==","os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:49a0b15145b6415d136ba894bd24d77efc211c25e5d46c81ee5669920af19658"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a new file mode 100644 index 000000000..96878321c --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/d82c5848ce1ff8b90a831cd1b5cb5c8821e870dad8c56e7093a58c52bafeb48a @@ -0,0 +1 @@ +{"architecture":"amd64","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-10T20:56:22.923857404Z","history":[{"created":"2023-03-10T20:56:22.923857404Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-10T20:56:22.923857404Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"moby.buildkit.buildinfo.v1":"eyJmcm9udGVuZCI6ImRvY2tlcmZpbGUudjAifQ==","os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:49a0b15145b6415d136ba894bd24d77efc211c25e5d46c81ee5669920af19658"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e new file mode 100644 index 000000000..83fcb0aaf Binary files /dev/null and b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/da7635ad81c0a167bb7dd16fec517f29763c74fd9a7e4addabd9018ba916984e differ diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/f8859996f481d0332f486fca612ac64f4fc31b94d03f45086ed3e1aa3df3f5f7 b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/f8859996f481d0332f486fca612ac64f4fc31b94d03f45086ed3e1aa3df3f5f7 new file mode 100644 index 000000000..412dfc6db --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/blobs/sha256/f8859996f481d0332f486fca612ac64f4fc31b94d03f45086ed3e1aa3df3f5f7 @@ -0,0 +1,33 @@ +{ + "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", + "schemaVersion": 2, + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:8e7779499445140ccf598227b2211d973bf4fe1440262072633b9b11b5605d58", + "size": 501, + "platform": { + "architecture": "amd64", + "os": "linux" + } + }, + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:6b2012214d36a888aef3812050cce5593de111181ba60a6ec4d68a3901367790", + "size": 501, + "platform": { + "architecture": "ppc64le", + "os": "linux" + } + }, + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:0f443780f39cdfebb924e92f9fce6f05831e9bf6b6a7dbb0c09fe0086358a2ac", + "size": 501, + "platform": { + "architecture": "s390x", + "os": "linux" + } + } + ] +} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/index.json b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/index.json new file mode 100644 index 000000000..810bdecb1 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/index.json @@ -0,0 +1 @@ +{"schemaVersion":2,"manifests":[{"mediaType":"application/vnd.docker.distribution.manifest.list.v2+json","digest":"sha256:f8859996f481d0332f486fca612ac64f4fc31b94d03f45086ed3e1aa3df3f5f7","size":966}]} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/layout/oci-layout b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/oci-layout new file mode 100644 index 000000000..21b1439d1 --- /dev/null +++ b/pkg/cli/mirror/testdata/manifestlist/testonly/layout/oci-layout @@ -0,0 +1 @@ +{"imageLayoutVersion": "1.0.0"} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/manifestlist/testonly/opm b/pkg/cli/mirror/testdata/manifestlist/testonly/opm new file mode 100755 index 000000000..e69de29bb diff --git a/pkg/cli/mirror/testdata/single/testonly/Dockerfile b/pkg/cli/mirror/testdata/single/testonly/Dockerfile new file mode 100644 index 000000000..5d2f2270d --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/Dockerfile @@ -0,0 +1,22 @@ +# minimize size by using scratch in builder and final image +FROM scratch as builder + +# Create fake /bin/opm and /bin/grpc_health_probe +# Because these are fake you can never use this as a real catalog +# and there is no way to pre-populate the opm serve cache +COPY opm grpc_health_probe /bin/ + +# Copy declarative config root into image at /configs +COPY configs /configs + +FROM scratch +# Configure the entrypoint and command +ENTRYPOINT ["/bin/opm"] +CMD ["serve", "/configs", "--cache-dir=/tmp/cache"] + +# Use a single copy from the builder to get one layer +COPY --from=builder / / + +# Set DC-specific label for the location of the DC root directory +# in the image +LABEL operators.operatorframework.io.index.configs.v1=/configs diff --git a/pkg/cli/mirror/testdata/single/testonly/README.md b/pkg/cli/mirror/testdata/single/testonly/README.md new file mode 100644 index 000000000..a72b16f75 --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/README.md @@ -0,0 +1,7 @@ +# NOTICE + +This folder contains all of the information needed to create a dummy OCI layout in the directory called "layout". +This OCI layout can only be used for test case purposes. The single image is built +off of scratch in order to minimize its size. While this image contains a declarative config, it is NOT a +deployable catalog since it does not contain real executables nor does it contain any libraries that +would normally be necessary to support an executable. In other words, this image WILL NOT RUN. \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/single/testonly/build.sh b/pkg/cli/mirror/testdata/single/testonly/build.sh new file mode 100755 index 000000000..48be9cd70 --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/build.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash + +# simple steps to build a single arch image and copy it to the ./layout directory + +export DOCKER_DEFAULT_PLATFORM=linux/amd64 + +docker build -t testonly:v1.0.0 . + +skopeo copy --src-tls-verify=false docker-daemon:testonly:v1.0.0 oci:layout --all --format v2s2 diff --git a/pkg/cli/mirror/testdata/single/testonly/configs/aws-load-balancer-operator/catalog.json b/pkg/cli/mirror/testdata/single/testonly/configs/aws-load-balancer-operator/catalog.json new file mode 100644 index 000000000..c1fc6b54f --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/configs/aws-load-balancer-operator/catalog.json @@ -0,0 +1,146 @@ +{ + "schema": "olm.package", + "name": "aws-load-balancer-operator", + "defaultChannel": "stable-v0.1", + "icon": { + "base64data": "iVBORw0KGgoAAAANSUhEUgAAAHgAAAB4EAIAAADmln3GAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0T///////8JWPfcAAAACXBIWXMAAADwAAAA8ACcTN6WAAAAB3RJTUUH5gQbCC4hNyxsqwAAIwlJREFUeNrtXXdcU2fbBgmYhLBHUDaCYS8VNCyhrVCw4qgTx6uiVos4PwFtESeitipqHaDWhXtgBcW2gEwBmTIFkb33CFu+P+76lfeL53CyQ8j1R37+PE/OeHLxnPu5x3WLDg8PDw8PiwghhEBgAq9vQAgh2AkhoYUQKAgJLYRAQUhoIQQKOF7fwNjA8PCnT8PDDQ01NTRadXVZWWdndfXHj58/6+oqK7u7abTOzoGBnh4abXCwr6+nZ3Cwq7O9baC/t6+nd3AIzoOfSMDjxEhSMrLiEhMnEgg4HIFAJOJwkpLS0uI4MllNTZKkqqqtLSUFn2pq2tpSUkpKkyYRiaKiEyaIivJ6JvgdokIvx0j09/f2Dg0VFGRmNje/e5eS0tCQk/PmTUNDaWlBQVtbf39f39AQ9+9KQmLiRDExHR1DA1lZU1PrmcrKJibW1srKBgYWFgoKEhJ4vJgYr2eOXzCuCd3UVFtLo71+/fx5RUVGenx8XV1hUVZmc9PAQP/ApzEwJ0B0CsXcTEHe0tLWjqzi4DB3roaGouKkSUQir++ONxhHhIbVNy0tNra2Njr66dOyjxkZ8XF1dUNDQ2OBvZgAZom+vrmZgoKT0/wFmpr29m5uGhoEgqQkblyYlwJOaLBxHz0KDS0qSkiIjKis6O3916IdD8DjCXicmK2tq5u6xqJFnp4UCljnvL4vTkEACf3xY2FhW9vDh5cvFxYmJLx8WVUFWzrWzywlJSsjIfF5u6YzRVpaVVVLi0SaPFlLS0pKXl5ZGY/H4wkEHA42fCSSjIy4OPwPnKG3t6dncLCrq719YAA2jvA/LS0NDb29NTX/bjerqkpLOzurq8s+dnZ2dra19/ezfv+wftvaurioqS1evGmTgYGWFoUiI8Pb34u9EBBCw6YtLCw4OC83LTU2tqZmWGR4WIRJn4C8vLIygWBqOnOmsvLIT2XlyZN5YZs2NFRXd3fn5KSkNDbCJhU+W1oaGnp6mDunqIioqMjwDCvH2ZNVPTy8txkZaWvr68vKcv/p2IsxTGhwk92+HRyclxfxPCyspOTT8NAQ488CK66jo7u7pqaNjbOzmtpYeSnDKp6YGBVVVRUbGx5eXlZdXVbW2cXoecTExCaIiri6eqzU1fPw8PY2MiISSSRxcV4/HzMYk4QGv8TVq0HHsrNbWxubenuxf1dKSkZaQsLefu53GhqOjvPmaWpOnWpmJi/P62diD4qKsrObm2Njnz2rqIiLe/5HRUVnZ3sHI+aKnJySIh6/fr2vn5kZbCh5/UyMYcwQuqmprq6n58wZP7/UlOzs5OSGRuzfVZAnkwmEhYvWr6dQ5sxZskRHZ+JEwffd9vX19g4NRUXdu1da+uTx1atFRc0t9fWMmChmZlQqWXn79sDAGVYKCmQygcDrZxodY4DQ2dnJyQ0Nv/yye1dKSltbcwu29VhZSXWyJNF9/pr/6E11dl66VEcHvLa8fhreYHBwYODTp7i4iIjKygcPLl4syMdunEhLyclNlNi+49ixGVbTpzs4TJrE66dBA58SemhoaGh4+Nat06dzcx8/Cg0tLMCyySPgJYk4seUrvLYaGX/33erVenpiYmJiwnDxf2NoaHDw06c//rh5s6QkLOxscF5eby+tZ3AQ/VuwiVz0/YYN+gYeHtu2GRvz59zyHaHb2pqbe3sDA7d6JScXFGRkNjVh+ZaNjYuzmpqnp99ec/Ox8nLkB4AhdyU0MDArKzEpKqqqCsu3DA2nTVNU9PUNDp41S1ZWQQGP5/Vz/As+IjSk+Pj7r18fF1dXV1HRNcoLUVFx0iQiYevWw4enz7CwsLEhk3n9BGMbGRkJCXV15879/HP626am2lraKNb2pEkaGiTSgQNXrtjbq6ioq0tK8voJRET4hNDl5cXF7e0B+z094+OxbFxgs7Jr14kTVtb8tkKMdXR2trX195865eubmvr2bWxsbS36eDk5RUU8fv/+y5ft7HR0DA157cnmMaFzc9PSGhsPH96yJTER/MpII8FXumTJ5i0GhsuWbdliaChMp+QcgBPPn9+8WVx87dqJEzk5sK1EGo/HEwk43N69585TqebmVCrv3pY8IzRQOSDA0zM+Hj0tU0ZaXn7ixH0/nT9vY6Ovb2GhoMCryRqfKCjIyGhqOnL4xx+TEjs6W1v7EL3a4EcKCAgNtbMzNp4xQ0mJ+3fLA0KXl79/397u57vSIzamq7ujsx9xVYZQM1hpYyV6J6iAXY2/v6dnfDz6DodIIJHEcUcDb9yY7ch9I4SrhIZtn4/P8uXR0a2tTSgRPnV1XV1p6QMHQkPt7RUVVVSEXgv+QGtrY2Nvb0DAhg3x8ZAEhjRSRlpBfuLEoONhd5ycJk/W1CSRuHOHXKopBGcceDDQqUyhmJkqyAcFhYU5OgqpzG+Qk1NSwuOPHLlxw8FBX9/cHNn8a+9obunrO3hg48b4uPb25ua+Pu7cIccJDSGSY8e8vZOT0V9VGhq6utJS/v6XQ2ztSCRpaQkJ7kyBEIwCfp2AgJAQOzsdHQMDZKOipra8vKv78OEtmxMTIKDD6XvjuMlx/fovv7x79+hRSEhhIdIYCFMHHQ+74+gkDIuwAkgo7e/v62MHdXA4HE5UVEFBRYVIFBX9skepubm+vqcHzEgoIkY62/ffb9yoT1m9eudOE1POzQAHCZ2eHhdXV3fwwKZN8XFIgWvwYBwLCgtzdFRV1dISbvsYR1lZUVF7+7FAb++kRFgR2Xt+8DTv2nXypLU15IXTj4GiBJ89K1bERCN5QsDNun//5cu2tpaWtrYqKpyYDY6YHBBQPfWrj09qChKVxcRwuAkTwBknpDIrOHfO/+e3aZygMgD2PL/8snt3SgpS7Q/4oPb9dP481QZ+Wfox8N1Tv+7Zk5oK6zon7pYjhIYkT3Sf5erVO3caGwv9yqzjw4e8/LZ2Tl8FaI1ORAMDS0tFxVWrtm83NkYa097R0tLXd+a0n19aGifuk82Ejo3944+KCvR85enTHBwmTZo/f+1aCoUTjzTe8GloaOgTl8p+YYuPPmbBgvXrKRQrKyfHyZORxmRlJyXV18fHR0RUVrL3DtlGaAhcX7t2PCg7G2kMpBPt2BkUZGWFtMkQPEC9I2yLP3zIz29tZVfRLhZA2hD2T0gxYAXwy3p7Hzk6fbqioooKATHT5sqVoKDsbBqtqws55YFRsE2rAWr70AuiIDNOSkpWdjy55BITX76sqnrw4NKlggLw+cBW2NRs1ixlZQsLKpVMhvwHTgjEXLr06pWrK/blY4Pn119FRtY3VFV3s2SRS0vLyU2c6OV16ND0GRCIoR8DPpmwsLNn8/I8Pf38zM1Zf142EBpWIChTRRoD+crjM8kzKyspqb5+5P+AHQkv3JGvXTVVHW0pKXMLqg2ZbG5uY0Mmm5paWysr4/FE4tiUibG0tLNTUaHOmjNHTS0p+dWrL+VbR0TcullS/NVXCxZoabFeec4GkwPEA5AqrqGKBFLvuTOJ/ANIxSwpyctrbcUyvqq69GNn5/Pnt26VlBw+vHlzYuKKFdbW4eEXLx48mJHx6RMzNe38AM8Nfn5mZpCRR38UlKvCbp89m5fL+rVYIjRE80EHA2kMFESNz3BJdnZycn09KxYzJG1GRoaFffgQGXnnzocPvH4mZgCm1LJlP3oZGiKNSU2Njq6pAZ86K9diidCgToTkaYZNBtT2cWvq+AsUirm5ggJYh+DbAWEu5s5WUpKb29LC62diHu7ua9bo6UFUmP4osAh2GqxchUlCQ2QoMQGtCm3Rog0b9PX5s5SSOwBd53nz1qzR0/Pff+mSre2OHcdPWFmTJKWlJBiWcVFRUVfnVs4aJwABl0Xfb9hI0UcaA4wCBW7mrsIkoUH+EMluBh0MJ6f587W0eDBzfIa8vLS0xkYfnxXLY2ICA7duTUpCzwJHAm8rQdiFr79euFBbGxhCfxQY9ehRSEhREXPnZ5jQIC6YkPAiEtklDpIu4uISEhPGacsLqJIMCtq+LTnZz2/VqthY7BXs9ICUeT09ExM5OV4/GasAVsxfsHbt1KlIYz7rxNJoo4kr0INhZ1BSUlRUVRWSkgPoc4I6Ea+njtuAF2VYWHBwXl5C/IsXlRWsCEaOBKQEIeVIoMPd3cDgwQNez83/h4vLsmVTpty/f/FCQQG9tipIHiclvXpVXe3kNH++pib2MzM8QTEx4eHlZUhH7exc3dTVx4PQFgDSsM6d8/dPf+vl5eYa9TI+PjKyshI7lfX1LcwVFEBRDmmMuQWVSuZIbhqvAAwBtiCNiYl59gyZaUhgYIWGBg45OSkpjYivTicnd3dBt5vBu/zwweVLhYUREWF3Skr6B3p7Gem9oqk5daqMzKpVO3YYG0MxqYfHzJnPniGNhyAL0lGcuDhuwgTutNFgrxkJbAGnJP3RnJw3bxoaYcnAXrvEAKFB8xM9gVCQlDxHAuy58PDff3///snjq1ffF9F6uroGGLDwwIm5YoW3t7Gxg4Obm7o65AeD/xWpmoOsrKYqKYlek2doOH2GklJ2dlJSfQPnZgBkZUA5m13nBLaoqmppSZHotfaAaXFxEREVFQsXrl+PLZWNgb82aKuDdBT0ldk/kbzDwEB//6dPf/xx40Zx8QbPb76OjIR8FexUBkNi8+b9+y0tL1x48cLFZfbs777T0BipKJKZkZjw34HxkYAwOPpVvL2PHJk+w9yMSiWTmbOzkTBBVExMVHSqnqmpvDwIf3FinmfPdnfX1EI6mpERH19Xi/1smFZoaLdT9D47G9mxD1LhnHhgbgLCy9HR4eHl5XfvnjuXl4deVkQP8DEvXOS5gaIPQSX0HUV+QXoGsvcD3dgAgLf74KGrV+3teT1/zACYc/v2mTO5Xwh9FxZmZja3gHILFv1YTISGvn1IcjDgU0TXzais/PCho6OioqSko0NEhJcZCUSilJS4uJHR9OmKiiMnKDU1Jqam5vr1kyfevaus/FDa0YH9nBD/mzt31Wpd3YULPT0p+tiLfE+cuHfPyamgID29qSkzMympvj4rKzGxvr68/H1RextSyZMgQU1NRwc61BAI9E02gHWFhZmZzc1YZgMToaGjB9JRE1Nra+TLPH167dr79yAnxc08YHRAhfnx43fuOH0FFP/4saCgrQ07lXE4cfEJE5ydlyzR0VmyZPNmAwOovWP0TuCPysyMSiWT4VNEZPduEZGuro6O/v7xU/0OZI2NffasvJz+KDAQC6Ex2VvQUxX9Vuj/H/62bt489es7PqIyoKKipKSjMyrqwYPSUvifefPWrJk6FeRRkL4Fti/sFn77LTLSxWXTpp9/trBgjsroGD9UBqCTFX1JHYlRVmggYukHNI0cU1Nr6y+pmEGrMn7uygpKTvBvaE25eMnGTQYGoaGBgVlZI0dCQdGqVTt2GhtraurpCVYrNH4AEosAwEBgI7pI5yiEbmysraXRkPysEBdUVlZV/bI2MO+FehnFt98uXz5lCrjnVMjq6pKSq1bv3Gligq4SxDqgVo/1RC5ITEBXCsUOMTExsQkTuNOFFlgEjKKPHQIDgY3IfBMRGZXQVVUfPyLnPbEioAjp3tOm2dtzRp8BUFdXUdndDZV8WMZD4ODkyQcPvvqKE4YEPUZuRg8cCL1iZ8doIVZNTXl5VxfIDJQU5+a2NLMr5A6AX3n79mPHZsygUMzMOPmHDdcqLMzMam6mPwpsZInQkCaKdFRNTVuHWULLyioq4fE+PqfPcMa7CXjx4s6dDx8uXDhwABuhAdykMoikwZq6d++aNa9fHz16/bqDA3Zanw3ety8trbj43bt/nKpsTtYFDhw/vn37mzehodHRbm6cK3AGRiERGu4EXaRmlE0hOqGFErfMgZ7K8P+g/Qe0hkQDLGdDjw+wC/C655xADACdUehsBIxC6JHbJkYvLwQ9IER14beAgIwMJEuXUVoPDQ4Ock+Xg7OCi+iMQmcjYBRC02hdKG0iZGW58WoWJEhI4PFiYgEHQkPt7EDMAGkkc6s1PSByif2Tt40+0BmF3rQEMIoN3UPr6kJOsubO/lfwAI6/wGO3bjk67tu3enVsLJJmNtDa19fDIybm6NGbN2fPRt8S0eN2WEqq+3zu63IwB3RG9dC6u0ZL+R+N0D002iDi3wSBMFb1ItABK8GLF3fvcr7KGqKDSBEyAOST/PTT2rVxcUeP3rgxe7agSsETCJKS4ojVlj293TRWV+je7u4B1BVanOFiT/4HhJ1B5YjX9/IvYLXev3/9uri4U6cePf76azBgeH1f7MQoK3TP6Cv0KDZ0T083TWhy8BMg2yQlJToaWQtl7IJIRGMUjdY9apXhOC1iFUJQMQqhCQRJIuoroJvxulwhWAHo31lbOzkhi9WOXdBoaIwiEiVH3bONcpiAl5QUx9HH1gE9Pd3dAwOCpyYKCaUglMPpa1VWlpR0tKemxsTUjFKXoaKioUEiHTx05aq9veBZzwD0JZJAkCSxSmgCkYhD3nX2MKOcwP+A1M01a3btMjHh3FWqqkpLOzvBbYc+EhqQHj587Zq9PSckd/kHsEQiHSXgJYmjOSFGIzSRRBKaHOwGVO7s27tmdWws9PNDGgmltZ9ddcxQ2WOFtVX4U+zju2ld3YwU/7IXo6zQRJZXaCKRJIX8N9HWhtZCUwh6QOg7IMDTM+41p6kMYE52jFdAZxSYguhnGGVTCNOKdBRLsogQIwG27w8/+PtbToMiLvoxjFJZDIfDTeCSPc3eqnJ6oDMKnY2AUW6O9ewnIehhZeXkNHmyr++ZM7NmjaQ1/GBHjjC2KlO4ooUCteWc1vlmPbtzFJMD/RRVVR9LmSV0R3tLS1/v+fP+/unpnJsgqDZn9FvQmVxWVkGBk6lXI2n9+7WTJ3JyDhy8ctXeHqiD/TxeWw8fnj79l5O7d6WklHzIxdgtADtACGb79qCgGRxv9YTOKDYQWk2NUys0yLVERd2//7lMlR8A4jK7dy9e/PffKioaGiTJ1at37DAx5ZwiFNB62jQHh0mTmCvBgralv556+Ojrr8duCRZg1IISVgkNq4WEOB4vJkZfWQj+6YaG6uru7i9lgY291m0vX969++EDJAPB5//sXrbs77+srb/6SlV15art241NNDR0daWl2XtddsnC4/EEAg4nIjL2EpeARUgRD2AglnfXKDY0ZMfqTEHrTYRUYi4vr6yMxyNtffgBIzcZoF53/96li//dEgHq896k/PVXdY33Vnf3V69On/b1TU2FH4DXTyA4QBcqAAZiydXGRLXRNBNSUhq/0DcWJFRWr96508SEt2nj9AChGWfnxYs/61iHh1+/XlyM7koDffno6KdPy8t/+MHF5eXLSxcPHczMBJubvXfY3d3Rwb52lPyPnJw3bxoQNf6wK0hhso1MTKytlZXv37948UsNXdD/tubPX7t26lSo7oZCTrBTeTVx8NoyNrayUlIaKQWmrU2hyMhApgS0V0M/D9ipEZG3w0pK/o5+/Ljs47x5a/6jN3XBgnXrKBRJSWlpbIm1IMdTUJCR0dycmZmYWFeXlZWUVF9XXl5U2N5+40ZS8jx3KSkZGcFKLqAHukwzdkKLDg+Prp4B4QDomYekcAdKQqBTxuvJYR6gjxEd/eRJWdmdO+fP5+c1NdXW0hgoC5WSkpGWkFi0aMNGfX03t5UrdXXRxRq3bZs//88/oUEe/VEfnzNnZs0SDCFMJIAn6scf3dyiouiPwqITFpaa6u7ONrFGCAdQKOZmCvLv3qWkfqkxfWJiVFRV1dKlmzcbGPB6ipgHbM6++eb777W1HRy++05DA4QQHj64fLmwEDrAop+hs7O9o7//999PnszJefbsxo3i4qVLt2wxMJgz5/vvtbXpAxOGBtMsFRWRCA3CjeiEhnrss8H79r19m5uXltbYyEYvxwRRkSlTjI3l5Ly8Dh6aPkNLi0Jht2oUNDlBOqqvb2GhII+FygAGtmuWlrZ2yI0RYmPRWlWMRcAkurv/5z9Tp14O+fNPV9fly728jIygNy6WM4CW5oULAQEZGZs3u7pGRdGLxqMrQGdlJiUiq0cDgoP37XublpWdlFRfzy4qA6DH6/v32TktrdC/ixPzHBv77FkFYvmZpaWdncok7GdjgNAODnPn/rdY90iAAvt7rmhEcB/gi12+3MvL0DAk9K+/Xd3mz1+7dqoe9pUDCqhA32jbtgUL/vwzLS02trbWxMTaWkkJ1kJ6QLFqbW1FRVcX0pnz89+mfWlTzl7APdDL3bKCoqLs7OZmeu1+ADANWIf9nAwQGoKxpqbW1kqKSGOio8PDy8rY9cD8CWlpObmJE9et8/ExM7948eVLF5c53yxerK2NREp6QAPgQ4d++CEh4cCBjRsSEqSl5eUnIkYlwfBAOjo4MMBRrYyRYO+GPiYmPBy5NNjUdOZMZSVGg+0Me4gdHd3dtbSRjsbHR0ZUVvb1MdZEZ+wC/si9th46NH36uXPPI5xdbG2+/VZdXVREVFQEk1Al9C9sbW1EyTLLykxKGs3wGFsAhgBbkMY4Os6bh9yqAgkMhzSpVGdnVdWLFw8ewOHouxVCpOfVq/v3S0vHW5dvyDTY43Pq1MyZ5eVbthgY3L17/lx+fmLiS5RNDxbk5KS8aahnTqE0PLygYPFiftPlgIgsUlwQOiJQqXPmqKoyemaGV2gIrtrafuuK3GHu8aMrV4qKeOtv5i1ASgakKEEgBvoRMne2blpH58DgCDnGMQxgxZMnV6++f480xs7Oba66Bh7PjOoLk0HpRYs8PSkU6JJEf7S5pb6+p+fvv588EXR7GgugE+Hx43fuOjn5+Z09S6Uy17we3ZIeK/jrr0ePPn5E2lwCoxYu9PTE1sSNHkxmUcHr1cbW2VlNDXqn0o95/Dg0tLDwm28WLdLS4nRiOH8CNOmSk//6q7o6Kysxsb7u3bvUlMYmpMbS6Kirq6xE9nXwP8Cl+OhhaEhRIdIYG1sXFzU1yB9k7ioskWzx4k2bDAyQNkCgFQnBBe5OHb+gsDArq7k5JOTIkaystLTY2No65qgM0NU1Nh7LTU2fPbt+vbi4obG6pvsLwpPAoiVLNm1iLTDHEqEhbjTDynH2ZETj/c6dc2fz86HBLbemjl9gZjZrFpnMSmIW5Cq6uXl46Oq6ui5fPmUKr5+JGcCb6u7d8+fy85DGQIIuNI1m5VpsSNz28PDeZmSUnv76dW0NxJZGAtakK6GBgVlZPr5nOKrXz28AxZIpOoYGsrJYaknAkDM3o84iky0sbWzJZEgLG+uSayEhR49mZfX29vQOfsGZC/77FR5btxoZs34tNkyTtra+vqysq6vHSl09aCRMPyYxKSqqqiojIyGhrg69pYDgwdyCakNWHkloaI1jZjqLSiabW1CpZLKFha0tmcxo8RX/Iz09Lq6uLjn5zz+rq5HGzJ27arXeVHZlibDt797Dw9vbyCgh4UVkZSVSmODcuZ9/Tn975syTJ9/METy9JSTY2rq4qGsQiSSSuIS5OZVKJk+ZYmiILV2ddWzaNGdOZCT28U3NtbU0NnigOzpaW/v6zp/393+bhjQGuseuWLF1q5ERu56XbYQmEkkkcfF163x8zcwgY+ELk9VUW0vr+fXXPXtS3vj7X7pkZz/2irQYh46OoaGsLHxy/+pY2jiwF5COHBy8b+/bt01NdXU9iBHQ9et9fc3M2GtQsdmVBqkkZmZUKhkxHTs9PS6urv7Jk6tXi4rYe/XxiQliE7i2LGCJU4K7NjU1OgZZ8NfCwoZKVrazc0UJzzE5G5x47O3bAwNnWKH3ELl589Sp3NyCgoyMpiZGzi3E/wfkK3P6KtDqDj1VKD8/Pb2p6dat06dyEYXiofn0tm2Bx2ZYceI+OUJoeOwdO4OCrKyQLEXop3T0iJdXUpJQsIYVQOr9pEkaGiQSJ84PVN616+RJa2ukXxOEJ48e8fJKSqT3dAHguzt3HT9hbQ3WMyfuFlMJFiu4cePXX9+9e/jw8uVCxPgQqGsGBd254+TEaW0ewQb0EWRXFo2YGA4nKqqoSCYTCEhUhiv6+CxfHh0Nwg9IZ1uy5IcfDAxWrty+3ZgN7jkkcJzQkCMGorHwSkIaqamhpysjE3jsdtjs2SBoy7m7EoJ1QCcaP1+PFbGx5RXFJe3tSCONjGZMV1I6fPj36w4O7FIgQQLH8yvgAXx9g4NnzUJ/LcKkHDy4cWNCAkwWp+9NCOYAv87Bg5s2JiSgUxlkxHx9zwTPmsVpKgM4vkKPRH19VVV39549y5dFR6OntKur6+pKSx84EBLCeDN3ITiH1tbGxt7egIANG+LjkQp7AWAlBwWFhTk6kslqaoz0VmQFXM2Agwc7ePDKVXt79BTKysqSko4OaDgp3DLyA6Am0sfHwyMmBp3KRAKJJI7z9790ydaWm1QG8CClExJQ9u47/xvVBr3IFDYZPntWrIiJFjr4eAXY+ezetXRp9N9Aa6SR8Gv+9POFCza2OjoGBrwIJHHV5KBHbm5aWmPj4cNbtiQmondyhhSWJUs2bzEwXLZsyxZDQ36TFxMkACeeP795s7j46tXjx3Ny0NvW4/FEAg63d++581QqhPd5dec8JjSgvLy4uL09YL+nZ3w8VLugj4dI5K5dJ05YWXNaxXm8AXIwTp/y9U1Le5v++nXtKL25wEu9f39IiJ0dr1blkeALQgNgy7jff/36uNc1teXlXaNkICgqqqgQ8F5ehw5Nn2FpaWc3njL4OAHIjIN0IvQcDAB4MAICQkPt7LlvKyOBjwgNaG9vbu7rOxa4bVtSUl7+27fY7GbqrDlz1NQ8N/j5mZkJvSLYAan3kK+MnuQ5EuBXBmecjAxaggP3wXeEBkA4JiwsODgv7+HDkJDCwpHyWUiA8vdly7y2Ghq5u69Zo6c3PmsZ0QHWcHj4778XF0MVCVLq/UjAjmXx4o0b9fWXL9+61ciIO35lRsGnhB4JkOuFlNTWVqyN5CCcDsp0zs5LlujoCGr3VSyAAtW4uIiIysp79377LT8fXV5sJKSl5OQmSuzYGRRkZQ2yyLx+GjSMAUIDIGfgzGk/v7R/hAmxf1dBnkwmEBYsXLeOQnF2XrpURwdd4lYwAOpEUVH37pWWPn585UpREaPKdJDkCZlxnEsnYi/GDKFHIj4+IqKy8sqVoKDsbEZ/JNBvtref+52GxuzZ8+ZpaFAoZmbMSsDwG0D+EDTj4uMjnldWgrwv9jMAcSH1nhP5ypzGmCQ0gEbr6hoYCAs7ezYvLyLi1s2SYqTERXTAbn32bHd3TS1QYh4rsu0gFQ76yiBKi6TkiQ7w8UNtHyisQv0Rr5+PGYxhQo8EBGPDbp89m5ebmhodXVMDzX6YOxusUtAGYeQn2OXcfzpoUAR7CehFkp39JrmhET0fBh2ggwFN5TxWensbm3BCzJz7EBBCjwSI1T54cPlyQUFCwosXVVVYPCRYANXaIDagpqYzRVpaVVVLi0SaPFlLS0oKun6BIhuBQCTicNCbmkiUlPy82tFo3d0DAxAT7emh0QYHoftWS0tDQ29vTU1ZWWcn5K5Aynx1ddnHzk4kUUNGAUJboE4Eki6s62DwGwSQ0CNRXV1W1tn56FFISFFRQkJkRGUFFheVIAFcmSB/CJpxrAht8T8EnNAjAa2PQDc/Ovrp07KPGRnxcXV1zFne/AnwFuvrm5spKDg5zV+gqWlv7+amoTHWpWoYmIHxQ2h6gEBZXFxEREVFRkZ8fF1tYWFmZnMLUqcvfgNkt0FbHehFAlX347mMbVwTmh5A5cLCzMzm5s+bsJQ3DQ2lpfkFbW28IjoQV0fH0EBW1tTU+v82qfr6FhYKCtj7vIwHCAmNCbCthPxssMth6wafIObS3d3RPtDf20OjDQ719NBog/9s/mi0btrAP4qjRKIkUfyfzSKBQCTixPEEIhEnRiLJyIqLk8lqapIk2HR+3npqa0tJgUSYMF0WC4SEFkKgIEzcEUKgICS0EAIFIaGFECgICS2EQOF/ATELYvgIQNylAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDIyLTA0LTI3VDA4OjQ0OjU1KzAwOjAwG4jrdAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAyMi0wNC0yN1QwODo0NDo1NSswMDowMGrVU8gAAAAASUVORK5CYII=", + "mediatype": "image/png" + } +} +{ + "schema": "olm.channel", + "name": "alpha", + "package": "aws-load-balancer-operator", + "entries": [ + { + "name": "aws-load-balancer-operator.v0.0.1" + } + ] +} +{ + "schema": "olm.channel", + "name": "stable-v0.1", + "package": "aws-load-balancer-operator", + "entries": [ + { + "name": "aws-load-balancer-operator.v0.0.1" + } + ] +} +{ + "schema": "olm.bundle", + "name": "aws-load-balancer-operator.v0.0.1", + "package": "aws-load-balancer-operator", + "image": "registry.redhat.io/albo/aws-load-balancer-operator-bundle@sha256:50b9402635dd4b312a86bed05dcdbda8c00120d3789ec2e9b527045100b3bdb4", + "properties": [ + { + "type": "olm.gvk", + "value": { + "group": "elbv2.k8s.aws", + "kind": "IngressClassParams", + "version": "v1beta1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "elbv2.k8s.aws", + "kind": "TargetGroupBinding", + "version": "v1alpha1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "elbv2.k8s.aws", + "kind": "TargetGroupBinding", + "version": "v1beta1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "networking.olm.openshift.io", + "kind": "AWSLoadBalancerController", + "version": "v1alpha1" + } + }, + { + "type": "olm.package", + "value": { + "packageName": "aws-load-balancer-operator", + "version": "0.0.1" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJraW5kIjoiU2VydmljZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJsYWJlbHMiOnsiY29udHJvbC1wbGFuZSI6ImNvbnRyb2xsZXItbWFuYWdlciJ9LCJuYW1lIjoiYXdzLWxvYWQtYmFsYW5jZXItb3BlcmF0b3ItY29udHJvbGxlci1tYW5hZ2VyLW1ldHJpY3Mtc2VydmljZSJ9LCJzcGVjIjp7InBvcnRzIjpbeyJuYW1lIjoiaHR0cHMiLCJwb3J0Ijo4NDQzLCJwcm90b2NvbCI6IlRDUCIsInRhcmdldFBvcnQiOiJodHRwcyJ9XSwic2VsZWN0b3IiOnsiY29udHJvbC1wbGFuZSI6ImNvbnRyb2xsZXItbWFuYWdlciJ9fSwic3RhdHVzIjp7ImxvYWRCYWxhbmNlciI6e319fQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJkYXRhIjp7ImNvbnRyb2xsZXJfbWFuYWdlcl9jb25maWcueWFtbCI6ImFwaVZlcnNpb246IGNvbnRyb2xsZXItcnVudGltZS5zaWdzLms4cy5pby92MWFscGhhMVxua2luZDogQ29udHJvbGxlck1hbmFnZXJDb25maWdcbmhlYWx0aDpcbiAgaGVhbHRoUHJvYmVCaW5kQWRkcmVzczogOjgwODFcbm1ldHJpY3M6XG4gIGJpbmRBZGRyZXNzOiAxMjcuMC4wLjE6ODA4MFxud2ViaG9vazpcbiAgcG9ydDogOTQ0M1xubGVhZGVyRWxlY3Rpb246XG4gIGxlYWRlckVsZWN0OiB0cnVlXG4gIHJlc291cmNlTmFtZTogN2RlNTFjZjMub3BlbnNoaWZ0LmlvXG4ifSwia2luZCI6IkNvbmZpZ01hcCIsIm1ldGFkYXRhIjp7Im5hbWUiOiJhd3MtbG9hZC1iYWxhbmNlci1vcGVyYXRvci1tYW5hZ2VyLWNvbmZpZyJ9fQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJuYW1lIjoiYXdzLWxvYWQtYmFsYW5jZXItb3BlcmF0b3ItbWV0cmljcy1yZWFkZXIifSwicnVsZXMiOlt7Im5vblJlc291cmNlVVJMcyI6WyIvbWV0cmljcyJdLCJ2ZXJicyI6WyJnZXQiXX1dfQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"annotations":{"alm-examples":"[\n  {\n    \"apiVersion\": \"elbv2.k8s.aws/v1alpha1\",\n    \"kind\": \"TargetGroupBinding\",\n    \"metadata\": {\n      \"name\": \"my-tgb\"\n    },\n    \"spec\": {\n      \"serviceRef\": {\n        \"name\": \"awesome-service\",\n        \"port\": 80\n      },\n      \"targetGroupARN\": \"\\u003carn-to-targetGroup\\u003e\"\n    }\n  },\n  {\n    \"apiVersion\": \"elbv2.k8s.aws/v1beta1\",\n    \"kind\": \"IngressClassParams\",\n    \"metadata\": {\n      \"name\": \"awesome-class\"\n    },\n    \"spec\": {\n      \"group\": {\n        \"name\": \"my-group\"\n      }\n    }\n  },\n  {\n    \"apiVersion\": \"elbv2.k8s.aws/v1beta1\",\n    \"kind\": \"TargetGroupBinding\",\n    \"metadata\": {\n      \"name\": \"my-tgb\"\n    },\n    \"spec\": {\n      \"serviceRef\": {\n        \"name\": \"awesome-service\",\n        \"port\": 80\n      },\n      \"targetGroupARN\": \"\\u003carn-to-targetGroup\\u003e\"\n    }\n  },\n  {\n    \"apiVersion\": \"networking.olm.openshift.io/v1alpha1\",\n    \"kind\": \"AWSLoadBalancerController\",\n    \"metadata\": {\n      \"name\": \"cluster\"\n    },\n    \"spec\": {\n      \"subnetTagging\": \"Auto\"\n    }\n  }\n]","capabilities":"Basic Install","containerImage":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","createdAt":"2022-06-28T17:56:41","operators.operatorframework.io/builder":"operator-sdk-v1.16.0+git","operators.operatorframework.io/project_layout":"go.kubebuilder.io/v3"},"name":"aws-load-balancer-operator.v0.0.1","namespace":"placeholder"},"spec":{"apiservicedefinitions":{},"customresourcedefinitions":{"owned":[{"description":"AWSLoadBalancerController is the Schema for the awsloadbalancercontrollers API","displayName":"AWSLoad Balancer Controller","kind":"AWSLoadBalancerController","name":"awsloadbalancercontrollers.networking.olm.openshift.io","version":"v1alpha1"},{"kind":"IngressClassParams","name":"ingressclassparams.elbv2.k8s.aws","version":"v1beta1"},{"kind":"TargetGroupBinding","name":"targetgroupbindings.elbv2.k8s.aws","version":"v1alpha1"},{"kind":"TargetGroupBinding","name":"targetgroupbindings.elbv2.k8s.aws","version":"v1beta1"}]},"description":"Operator to simplify management of aws-load-balancer-controller\n\n### Prerequisites for installation\nThe operator requires AWS credentials in the installation namespace before it can be installed.\n\n1. Create the operator namespace with the following command:\n```bash\noc create namespace aws-load-balancer-operator\n```\n2. Create the `CredentialsRequest` in the `openshift-cloud-credential-operator`\n   namespace with the following command:\n\n```\ncat \u003c\u003c EOF| oc create -f -\napiVersion: cloudcredential.openshift.io/v1\nkind: CredentialsRequest\nmetadata:\n  name: aws-load-balancer-operator\n  namespace: openshift-cloud-credential-operator\nspec:\n  providerSpec:\n    apiVersion: cloudcredential.openshift.io/v1\n    kind: AWSProviderSpec\n    statementEntries:\n      - action:\n          - ec2:DescribeSubnets\n        effect: Allow\n        resource: \"*\"\n      - action:\n          - ec2:CreateTags\n          - ec2:DeleteTags\n        effect: Allow\n        resource: arn:aws:ec2:*:*:subnet/*\n      - action:\n          - ec2:DescribeVpcs\n        effect: Allow\n        resource: \"*\"\n  secretRef:\n    name: aws-load-balancer-operator\n    namespace: aws-load-balancer-operator\n  serviceAccountNames:\n    - aws-load-balancer-operator-controller-manager\n  EOF\n```\n3. Ensure the credentials have been correctly provisioned\n```bash\noc get secret -n aws-load-balancer-operator aws-load-balancer-operator\n```\n\nAfter this the operator can be installated through the console or through the command line.\n\n__Note:__ For UPI based installs, additional documentation can be found\n[here](https://github.com/openshift/aws-load-balancer-operator/blob/main/docs/prerequisites.md#vpc-and-subnets)","displayName":"AWS Load Balancer Operator","icon":[{"base64data":"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","mediatype":"image/png"}],"install":{"spec":{"clusterPermissions":[{"rules":[{"apiGroups":["admissionregistration.k8s.io"],"resources":["mutatingwebhookconfigurations","validatingwebhookconfigurations"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["cloudcredential.openshift.io"],"resources":["credentialsrequests","credentialsrequests/finalizers","credentialsrequests/status"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["config.openshift.io"],"resources":["infrastructures"],"verbs":["get","list","watch"]},{"apiGroups":["networking.k8s.io"],"resources":["ingressclasses"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["networking.olm.openshift.io"],"resources":["awsloadbalancercontrollers"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["networking.olm.openshift.io"],"resources":["awsloadbalancercontrollers/finalizers"],"verbs":["update"]},{"apiGroups":["networking.olm.openshift.io"],"resources":["awsloadbalancercontrollers/status"],"verbs":["get","patch","update"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["clusterrolebindings"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resourceNames":["aws-load-balancer-operator-controller-role"],"resources":["clusterroles"],"verbs":["bind","get"]},{"apiGroups":["authentication.k8s.io"],"resources":["tokenreviews"],"verbs":["create"]},{"apiGroups":["authorization.k8s.io"],"resources":["subjectaccessreviews"],"verbs":["create"]}],"serviceAccountName":"aws-load-balancer-operator-controller-manager"}],"deployments":[{"name":"aws-load-balancer-operator-controller-manager","spec":{"replicas":1,"selector":{"matchLabels":{"control-plane":"controller-manager"}},"strategy":{},"template":{"metadata":{"annotations":{"kubectl.kubernetes.io/default-container":"manager"},"labels":{"control-plane":"controller-manager"}},"spec":{"containers":[{"args":["--secure-listen-address=0.0.0.0:8443","--upstream=http://127.0.0.1:8080/","--logtostderr=true","--v=0"],"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc","name":"kube-rbac-proxy","ports":[{"containerPort":8443,"name":"https","protocol":"TCP"}],"resources":{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"5m","memory":"64Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]}}},{"args":["--health-probe-bind-address=:8081","--metrics-bind-address=127.0.0.1:8080","--leader-elect","--image=$(RELATED_IMAGE_CONTROLLER)","--namespace=$(TARGET_NAMESPACE)"],"command":["/manager"],"env":[{"name":"AWS_SHARED_CREDENTIALS_FILE","value":"/etc/aws-credentials/credentials"},{"name":"RELATED_IMAGE_CONTROLLER","value":"registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece"},{"name":"TARGET_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.annotations['olm.targetNamespaces']"}}}],"image":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","livenessProbe":{"httpGet":{"path":"/healthz","port":8081},"initialDelaySeconds":15,"periodSeconds":20},"name":"manager","readinessProbe":{"httpGet":{"path":"/readyz","port":8081},"initialDelaySeconds":5,"periodSeconds":10},"resources":{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"10m","memory":"64Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]}},"volumeMounts":[{"mountPath":"/etc/aws-credentials","name":"aws-credentials"}]}],"securityContext":{"runAsNonRoot":true,"seccompProfile":{"type":"RuntimeDefault"}},"serviceAccountName":"aws-load-balancer-operator-controller-manager","terminationGracePeriodSeconds":10,"volumes":[{"name":"aws-credentials","secret":{"items":[{"key":"credentials","path":"credentials"}],"secretName":"aws-load-balancer-operator"}}]}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["configmaps"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":["coordination.k8s.io"],"resources":["leases"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":[""],"resources":["events"],"verbs":["create","patch"]},{"apiGroups":[""],"resources":["secrets","services"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":[""],"resources":["serviceaccounts"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["apps"],"resources":["deployments"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["rolebindings","roles"],"verbs":["create","delete","get","list","patch","update","watch"]}],"serviceAccountName":"aws-load-balancer-operator-controller-manager"}]},"strategy":"deployment"},"installModes":[{"supported":true,"type":"OwnNamespace"},{"supported":true,"type":"SingleNamespace"},{"supported":false,"type":"MultiNamespace"},{"supported":false,"type":"AllNamespaces"}],"keywords":["aws","load-balancer","ALB","ingress"],"links":[{"name":"Aws Load Balancer Operator","url":"https://aws-load-balancer-operator.domain"}],"maturity":"alpha","minKubeVersion":"1.20.0","provider":{"name":"Red Hat","url":"https://redhat.com"},"relatedImages":[{"image":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","name":"aws-load-balancer-rhel8-operator-95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d-annotation"},{"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc","name":"kube-rbac-proxy"},{"image":"registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d","name":"manager"},{"image":"registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece","name":"controller"}],"version":"0.0.1"}}" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoiYXBpZXh0ZW5zaW9ucy5rOHMuaW8vdjEiLCJraW5kIjoiQ3VzdG9tUmVzb3VyY2VEZWZpbml0aW9uIiwibWV0YWRhdGEiOnsiYW5ub3RhdGlvbnMiOnsiY29udHJvbGxlci1nZW4ua3ViZWJ1aWxkZXIuaW8vdmVyc2lvbiI6InYwLjUuMCJ9LCJjcmVhdGlvblRpbWVzdGFtcCI6bnVsbCwibmFtZSI6ImluZ3Jlc3NjbGFzc3BhcmFtcy5lbGJ2Mi5rOHMuYXdzIn0sInNwZWMiOnsiZ3JvdXAiOiJlbGJ2Mi5rOHMuYXdzIiwibmFtZXMiOnsia2luZCI6IkluZ3Jlc3NDbGFzc1BhcmFtcyIsImxpc3RLaW5kIjoiSW5ncmVzc0NsYXNzUGFyYW1zTGlzdCIsInBsdXJhbCI6ImluZ3Jlc3NjbGFzc3BhcmFtcyIsInNpbmd1bGFyIjoiaW5ncmVzc2NsYXNzcGFyYW1zIn0sInNjb3BlIjoiQ2x1c3RlciIsInZlcnNpb25zIjpbeyJhZGRpdGlvbmFsUHJpbnRlckNvbHVtbnMiOlt7ImRlc2NyaXB0aW9uIjoiVGhlIEluZ3Jlc3MgR3JvdXAgbmFtZSIsImpzb25QYXRoIjoiLnNwZWMuZ3JvdXAubmFtZSIsIm5hbWUiOiJHUk9VUC1OQU1FIiwidHlwZSI6InN0cmluZyJ9LHsiZGVzY3JpcHRpb24iOiJUaGUgQVdTIExvYWQgQmFsYW5jZXIgc2NoZW1lIiwianNvblBhdGgiOiIuc3BlYy5zY2hlbWUiLCJuYW1lIjoiU0NIRU1FIiwidHlwZSI6InN0cmluZyJ9LHsiZGVzY3JpcHRpb24iOiJUaGUgQVdTIExvYWQgQmFsYW5jZXIgaXBBZGRyZXNzVHlwZSIsImpzb25QYXRoIjoiLnNwZWMuaXBBZGRyZXNzVHlwZSIsIm5hbWUiOiJJUC1BRERSRVNTLVRZUEUiLCJ0eXBlIjoic3RyaW5nIn0seyJqc29uUGF0aCI6Ii5tZXRhZGF0YS5jcmVhdGlvblRpbWVzdGFtcCIsIm5hbWUiOiJBR0UiLCJ0eXBlIjoiZGF0ZSJ9XSwibmFtZSI6InYxYmV0YTEiLCJzY2hlbWEiOnsib3BlbkFQSVYzU2NoZW1hIjp7ImRlc2NyaXB0aW9uIjoiSW5ncmVzc0NsYXNzUGFyYW1zIGlzIHRoZSBTY2hlbWEgZm9yIHRoZSBJbmdyZXNzQ2xhc3NQYXJhbXMgQVBJIiwicHJvcGVydGllcyI6eyJhcGlWZXJzaW9uIjp7ImRlc2NyaXB0aW9uIjoiQVBJVmVyc2lvbiBkZWZpbmVzIHRoZSB2ZXJzaW9uZWQgc2NoZW1hIG9mIHRoaXMgcmVwcmVzZW50YXRpb24gb2YgYW4gb2JqZWN0LiBTZXJ2ZXJzIHNob3VsZCBjb252ZXJ0IHJlY29nbml6ZWQgc2NoZW1hcyB0byB0aGUgbGF0ZXN0IGludGVybmFsIHZhbHVlLCBhbmQgbWF5IHJlamVjdCB1bnJlY29nbml6ZWQgdmFsdWVzLiBNb3JlIGluZm86IGh0dHBzOi8vZ2l0Lms4cy5pby9jb21tdW5pdHkvY29udHJpYnV0b3JzL2RldmVsL3NpZy1hcmNoaXRlY3R1cmUvYXBpLWNvbnZlbnRpb25zLm1kI3Jlc291cmNlcyIsInR5cGUiOiJzdHJpbmcifSwia2luZCI6eyJkZXNjcmlwdGlvbiI6IktpbmQgaXMgYSBzdHJpbmcgdmFsdWUgcmVwcmVzZW50aW5nIHRoZSBSRVNUIHJlc291cmNlIHRoaXMgb2JqZWN0IHJlcHJlc2VudHMuIFNlcnZlcnMgbWF5IGluZmVyIHRoaXMgZnJvbSB0aGUgZW5kcG9pbnQgdGhlIGNsaWVudCBzdWJtaXRzIHJlcXVlc3RzIHRvLiBDYW5ub3QgYmUgdXBkYXRlZC4gSW4gQ2FtZWxDYXNlLiBNb3JlIGluZm86IGh0dHBzOi8vZ2l0Lms4cy5pby9jb21tdW5pdHkvY29udHJpYnV0b3JzL2RldmVsL3NpZy1hcmNoaXRlY3R1cmUvYXBpLWNvbnZlbnRpb25zLm1kI3R5cGVzLWtpbmRzIiwidHlwZSI6InN0cmluZyJ9LCJtZXRhZGF0YSI6eyJ0eXBlIjoib2JqZWN0In0sInNwZWMiOnsiZGVzY3JpcHRpb24iOiJJbmdyZXNzQ2xhc3NQYXJhbXNTcGVjIGRlZmluZXMgdGhlIGRlc2lyZWQgc3RhdGUgb2YgSW5ncmVzc0NsYXNzUGFyYW1zIiwicHJvcGVydGllcyI6eyJncm91cCI6eyJkZXNjcmlwdGlvbiI6Ikdyb3VwIGRlZmluZXMgdGhlIEluZ3Jlc3NHcm91cCBmb3IgYWxsIEluZ3Jlc3NlcyB0aGF0IGJlbG9uZyB0byBJbmdyZXNzQ2xhc3Mgd2l0aCB0aGlzIEluZ3Jlc3NDbGFzc1BhcmFtcy4iLCJwcm9wZXJ0aWVzIjp7Im5hbWUiOnsiZGVzY3JpcHRpb24iOiJOYW1lIGlzIHRoZSBuYW1lIG9mIEluZ3Jlc3NHcm91cC4iLCJ0eXBlIjoic3RyaW5nIn19LCJyZXF1aXJlZCI6WyJuYW1lIl0sInR5cGUiOiJvYmplY3QifSwiaXBBZGRyZXNzVHlwZSI6eyJkZXNjcmlwdGlvbiI6IklQQWRkcmVzc1R5cGUgZGVmaW5lcyB0aGUgaXAgYWRkcmVzcyB0eXBlIGZvciBhbGwgSW5ncmVzc2VzIHRoYXQgYmVsb25nIHRvIEluZ3Jlc3NDbGFzcyB3aXRoIHRoaXMgSW5ncmVzc0NsYXNzUGFyYW1zLiIsImVudW0iOlsiaXB2NCIsImR1YWxzdGFjayJdLCJ0eXBlIjoic3RyaW5nIn0sImxvYWRCYWxhbmNlckF0dHJpYnV0ZXMiOnsiZGVzY3JpcHRpb24iOiJMb2FkQmFsYW5jZXJBdHRyaWJ1dGVzIGRlZmluZSB0aGUgY3VzdG9tIGF0dHJpYnV0ZXMgdG8gTG9hZEJhbGFuY2VycyBmb3IgYWxsIEluZ3Jlc3MgdGhhdCB0aGF0IGJlbG9uZyB0byBJbmdyZXNzQ2xhc3Mgd2l0aCB0aGlzIEluZ3Jlc3NDbGFzc1BhcmFtcy4iLCJpdGVtcyI6eyJkZXNjcmlwdGlvbiI6IkF0dHJpYnV0ZXMgZGVmaW5lcyBjdXN0b20gYXR0cmlidXRlcyBvbiByZXNvdXJjZXMuIiwicHJvcGVydGllcyI6eyJrZXkiOnsiZGVzY3JpcHRpb24iOiJUaGUga2V5IG9mIHRoZSBhdHRyaWJ1dGUuIiwidHlwZSI6InN0cmluZyJ9LCJ2YWx1ZSI6eyJkZXNjcmlwdGlvbiI6IlRoZSB2YWx1ZSBvZiB0aGUgYXR0cmlidXRlLiIsInR5cGUiOiJzdHJpbmcifX0sInJlcXVpcmVkIjpbImtleSIsInZhbHVlIl0sInR5cGUiOiJvYmplY3QifSwidHlwZSI6ImFycmF5In0sIm5hbWVzcGFjZVNlbGVjdG9yIjp7ImRlc2NyaXB0aW9uIjoiTmFtZXNwYWNlU2VsZWN0b3IgcmVzdHJpY3QgdGhlIG5hbWVzcGFjZXMgb2YgSW5ncmVzc2VzIHRoYXQgYXJlIGFsbG93ZWQgdG8gc3BlY2lmeSB0aGUgSW5ncmVzc0NsYXNzIHdpdGggdGhpcyBJbmdyZXNzQ2xhc3NQYXJhbXMuICogaWYgYWJzZW50IG9yIHByZXNlbnQgYnV0IGVtcHR5LCBpdCBzZWxlY3RzIGFsbCBuYW1lc3BhY2VzLiIsInByb3BlcnRpZXMiOnsibWF0Y2hFeHByZXNzaW9ucyI6eyJkZXNjcmlwdGlvbiI6Im1hdGNoRXhwcmVzc2lvbnMgaXMgYSBsaXN0IG9mIGxhYmVsIHNlbGVjdG9yIHJlcXVpcmVtZW50cy4gVGhlIHJlcXVpcmVtZW50cyBhcmUgQU5EZWQuIiwiaXRlbXMiOnsiZGVzY3JpcHRpb24iOiJBIGxhYmVsIHNlbGVjdG9yIHJlcXVpcmVtZW50IGlzIGEgc2VsZWN0b3IgdGhhdCBjb250YWlucyB2YWx1ZXMsIGEga2V5LCBhbmQgYW4gb3BlcmF0b3IgdGhhdCByZWxhdGVzIHRoZSBrZXkgYW5kIHZhbHVlcy4iLCJwcm9wZXJ0aWVzIjp7ImtleSI6eyJkZXNjcmlwdGlvbiI6ImtleSBpcyB0aGUgbGFiZWwga2V5IHRoYXQgdGhlIHNlbGVjdG9yIGFwcGxpZXMgdG8uIiwidHlwZSI6InN0cmluZyJ9LCJvcGVyYXRvciI6eyJkZXNjcmlwdGlvbiI6Im9wZXJhdG9yIHJlcHJlc2VudHMgYSBrZXkncyByZWxhdGlvbnNoaXAgdG8gYSBzZXQgb2YgdmFsdWVzLiBWYWxpZCBvcGVyYXRvcnMgYXJlIEluLCBOb3RJbiwgRXhpc3RzIGFuZCBEb2VzTm90RXhpc3QuIiwidHlwZSI6InN0cmluZyJ9LCJ2YWx1ZXMiOnsiZGVzY3JpcHRpb24iOiJ2YWx1ZXMgaXMgYW4gYXJyYXkgb2Ygc3RyaW5nIHZhbHVlcy4gSWYgdGhlIG9wZXJhdG9yIGlzIEluIG9yIE5vdEluLCB0aGUgdmFsdWVzIGFycmF5IG11c3QgYmUgbm9uLWVtcHR5LiBJZiB0aGUgb3BlcmF0b3IgaXMgRXhpc3RzIG9yIERvZXNOb3RFeGlzdCwgdGhlIHZhbHVlcyBhcnJheSBtdXN0IGJlIGVtcHR5LiBUaGlzIGFycmF5IGlzIHJlcGxhY2VkIGR1cmluZyBhIHN0cmF0ZWdpYyBtZXJnZSBwYXRjaC4iLCJpdGVtcyI6eyJ0eXBlIjoic3RyaW5nIn0sInR5cGUiOiJhcnJheSJ9fSwicmVxdWlyZWQiOlsia2V5Iiwib3BlcmF0b3IiXSwidHlwZSI6Im9iamVjdCJ9LCJ0eXBlIjoiYXJyYXkifSwibWF0Y2hMYWJlbHMiOnsiYWRkaXRpb25hbFByb3BlcnRpZXMiOnsidHlwZSI6InN0cmluZyJ9LCJkZXNjcmlwdGlvbiI6Im1hdGNoTGFiZWxzIGlzIGEgbWFwIG9mIHtrZXksdmFsdWV9IHBhaXJzLiBBIHNpbmdsZSB7a2V5LHZhbHVlfSBpbiB0aGUgbWF0Y2hMYWJlbHMgbWFwIGlzIGVxdWl2YWxlbnQgdG8gYW4gZWxlbWVudCBvZiBtYXRjaEV4cHJlc3Npb25zLCB3aG9zZSBrZXkgZmllbGQgaXMgXCJrZXlcIiwgdGhlIG9wZXJhdG9yIGlzIFwiSW5cIiwgYW5kIHRoZSB2YWx1ZXMgYXJyYXkgY29udGFpbnMgb25seSBcInZhbHVlXCIuIFRoZSByZXF1aXJlbWVudHMgYXJlIEFORGVkLiIsInR5cGUiOiJvYmplY3QifX0sInR5cGUiOiJvYmplY3QifSwic2NoZW1lIjp7ImRlc2NyaXB0aW9uIjoiU2NoZW1lIGRlZmluZXMgdGhlIHNjaGVtZSBmb3IgYWxsIEluZ3Jlc3NlcyB0aGF0IGJlbG9uZyB0byBJbmdyZXNzQ2xhc3Mgd2l0aCB0aGlzIEluZ3Jlc3NDbGFzc1BhcmFtcy4iLCJlbnVtIjpbImludGVybmFsIiwiaW50ZXJuZXQtZmFjaW5nIl0sInR5cGUiOiJzdHJpbmcifSwidGFncyI6eyJkZXNjcmlwdGlvbiI6IlRhZ3MgZGVmaW5lcyBsaXN0IG9mIFRhZ3Mgb24gQVdTIHJlc291cmNlcyBwcm92aXNpb25lZCBmb3IgSW5ncmVzc2VzIHRoYXQgYmVsb25nIHRvIEluZ3Jlc3NDbGFzcyB3aXRoIHRoaXMgSW5ncmVzc0NsYXNzUGFyYW1zLiIsIml0ZW1zIjp7ImRlc2NyaXB0aW9uIjoiVGFnIGRlZmluZXMgYSBBV1MgVGFnIG9uIHJlc291cmNlcy4iLCJwcm9wZXJ0aWVzIjp7ImtleSI6eyJkZXNjcmlwdGlvbiI6IlRoZSBrZXkgb2YgdGhlIHRhZy4iLCJ0eXBlIjoic3RyaW5nIn0sInZhbHVlIjp7ImRlc2NyaXB0aW9uIjoiVGhlIHZhbHVlIG9mIHRoZSB0YWcuIiwidHlwZSI6InN0cmluZyJ9fSwicmVxdWlyZWQiOlsia2V5IiwidmFsdWUiXSwidHlwZSI6Im9iamVjdCJ9LCJ0eXBlIjoiYXJyYXkifX0sInR5cGUiOiJvYmplY3QifX0sInR5cGUiOiJvYmplY3QifX0sInNlcnZlZCI6dHJ1ZSwic3RvcmFnZSI6dHJ1ZSwic3VicmVzb3VyY2VzIjp7fX1dfSwic3RhdHVzIjp7ImFjY2VwdGVkTmFtZXMiOnsia2luZCI6IiIsInBsdXJhbCI6IiJ9LCJjb25kaXRpb25zIjpbXSwic3RvcmVkVmVyc2lvbnMiOltdfX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"apiextensions.k8s.io/v1","kind":"CustomResourceDefinition","metadata":{"annotations":{"controller-gen.kubebuilder.io/version":"v0.5.0"},"creationTimestamp":null,"name":"targetgroupbindings.elbv2.k8s.aws"},"spec":{"group":"elbv2.k8s.aws","names":{"kind":"TargetGroupBinding","listKind":"TargetGroupBindingList","plural":"targetgroupbindings","singular":"targetgroupbinding"},"scope":"Namespaced","versions":[{"additionalPrinterColumns":[{"description":"The Kubernetes Service's name","jsonPath":".spec.serviceRef.name","name":"SERVICE-NAME","type":"string"},{"description":"The Kubernetes Service's port","jsonPath":".spec.serviceRef.port","name":"SERVICE-PORT","type":"string"},{"description":"The AWS TargetGroup's TargetType","jsonPath":".spec.targetType","name":"TARGET-TYPE","type":"string"},{"description":"The AWS TargetGroup's Amazon Resource Name","jsonPath":".spec.targetGroupARN","name":"ARN","priority":1,"type":"string"},{"jsonPath":".metadata.creationTimestamp","name":"AGE","type":"date"}],"name":"v1alpha1","schema":{"openAPIV3Schema":{"description":"TargetGroupBinding is the Schema for the TargetGroupBinding API","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"TargetGroupBindingSpec defines the desired state of TargetGroupBinding","properties":{"networking":{"description":"networking provides the networking setup for ELBV2 LoadBalancer to access targets in TargetGroup.","properties":{"ingress":{"description":"List of ingress rules to allow ELBV2 LoadBalancer to access targets in TargetGroup.","items":{"properties":{"from":{"description":"List of peers which should be able to access the targets in TargetGroup. At least one NetworkingPeer should be specified.","items":{"description":"NetworkingPeer defines the source/destination peer for networking rules.","properties":{"ipBlock":{"description":"IPBlock defines an IPBlock peer. If specified, none of the other fields can be set.","properties":{"cidr":{"description":"CIDR is the network CIDR. Both IPV4 or IPV6 CIDR are accepted.","type":"string"}},"required":["cidr"],"type":"object"},"securityGroup":{"description":"SecurityGroup defines a SecurityGroup peer. If specified, none of the other fields can be set.","properties":{"groupID":{"description":"GroupID is the EC2 SecurityGroupID.","type":"string"}},"required":["groupID"],"type":"object"}},"type":"object"},"type":"array"},"ports":{"description":"List of ports which should be made accessible on the targets in TargetGroup. If ports is empty or unspecified, it defaults to all ports with TCP.","items":{"properties":{"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"The port which traffic must match. When NodePort endpoints(instance TargetType) is used, this must be a numerical port. When Port endpoints(ip TargetType) is used, this can be either numerical or named port on pods. if port is unspecified, it defaults to all ports.","x-kubernetes-int-or-string":true},"protocol":{"description":"The protocol which traffic must match. If protocol is unspecified, it defaults to TCP.","enum":["TCP","UDP"],"type":"string"}},"type":"object"},"type":"array"}},"required":["from","ports"],"type":"object"},"type":"array"}},"type":"object"},"serviceRef":{"description":"serviceRef is a reference to a Kubernetes Service and ServicePort.","properties":{"name":{"description":"Name is the name of the Service.","type":"string"},"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"Port is the port of the ServicePort.","x-kubernetes-int-or-string":true}},"required":["name","port"],"type":"object"},"targetGroupARN":{"description":"targetGroupARN is the Amazon Resource Name (ARN) for the TargetGroup.","type":"string"},"targetType":{"description":"targetType is the TargetType of TargetGroup. If unspecified, it will be automatically inferred.","enum":["instance","ip"],"type":"string"}},"required":["serviceRef","targetGroupARN"],"type":"object"},"status":{"description":"TargetGroupBindingStatus defines the observed state of TargetGroupBinding","properties":{"observedGeneration":{"description":"The generation observed by the TargetGroupBinding controller.","format":"int64","type":"integer"}},"type":"object"}},"type":"object"}},"served":true,"storage":false,"subresources":{"status":{}}},{"additionalPrinterColumns":[{"description":"The Kubernetes Service's name","jsonPath":".spec.serviceRef.name","name":"SERVICE-NAME","type":"string"},{"description":"The Kubernetes Service's port","jsonPath":".spec.serviceRef.port","name":"SERVICE-PORT","type":"string"},{"description":"The AWS TargetGroup's TargetType","jsonPath":".spec.targetType","name":"TARGET-TYPE","type":"string"},{"description":"The AWS TargetGroup's Amazon Resource Name","jsonPath":".spec.targetGroupARN","name":"ARN","priority":1,"type":"string"},{"jsonPath":".metadata.creationTimestamp","name":"AGE","type":"date"}],"name":"v1beta1","schema":{"openAPIV3Schema":{"description":"TargetGroupBinding is the Schema for the TargetGroupBinding API","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"TargetGroupBindingSpec defines the desired state of TargetGroupBinding","properties":{"ipAddressType":{"description":"ipAddressType specifies whether the target group is of type IPv4 or IPv6. If unspecified, it will be automatically inferred.","enum":["ipv4","ipv6"],"type":"string"},"networking":{"description":"networking defines the networking rules to allow ELBV2 LoadBalancer to access targets in TargetGroup.","properties":{"ingress":{"description":"List of ingress rules to allow ELBV2 LoadBalancer to access targets in TargetGroup.","items":{"description":"NetworkingIngressRule defines a particular set of traffic that is allowed to access TargetGroup's targets.","properties":{"from":{"description":"List of peers which should be able to access the targets in TargetGroup. At least one NetworkingPeer should be specified.","items":{"description":"NetworkingPeer defines the source/destination peer for networking rules.","properties":{"ipBlock":{"description":"IPBlock defines an IPBlock peer. If specified, none of the other fields can be set.","properties":{"cidr":{"description":"CIDR is the network CIDR. Both IPV4 or IPV6 CIDR are accepted.","type":"string"}},"required":["cidr"],"type":"object"},"securityGroup":{"description":"SecurityGroup defines a SecurityGroup peer. If specified, none of the other fields can be set.","properties":{"groupID":{"description":"GroupID is the EC2 SecurityGroupID.","type":"string"}},"required":["groupID"],"type":"object"}},"type":"object"},"type":"array"},"ports":{"description":"List of ports which should be made accessible on the targets in TargetGroup. If ports is empty or unspecified, it defaults to all ports with TCP.","items":{"description":"NetworkingPort defines the port and protocol for networking rules.","properties":{"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"The port which traffic must match. When NodePort endpoints(instance TargetType) is used, this must be a numerical port. When Port endpoints(ip TargetType) is used, this can be either numerical or named port on pods. if port is unspecified, it defaults to all ports.","x-kubernetes-int-or-string":true},"protocol":{"description":"The protocol which traffic must match. If protocol is unspecified, it defaults to TCP.","enum":["TCP","UDP"],"type":"string"}},"type":"object"},"type":"array"}},"required":["from","ports"],"type":"object"},"type":"array"}},"type":"object"},"nodeSelector":{"description":"node selector for instance type target groups to only register certain nodes","properties":{"matchExpressions":{"description":"matchExpressions is a list of label selector requirements. The requirements are ANDed.","items":{"description":"A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.","properties":{"key":{"description":"key is the label key that the selector applies to.","type":"string"},"operator":{"description":"operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.","type":"string"},"values":{"description":"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.","items":{"type":"string"},"type":"array"}},"required":["key","operator"],"type":"object"},"type":"array"},"matchLabels":{"additionalProperties":{"type":"string"},"description":"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.","type":"object"}},"type":"object"},"serviceRef":{"description":"serviceRef is a reference to a Kubernetes Service and ServicePort.","properties":{"name":{"description":"Name is the name of the Service.","type":"string"},"port":{"anyOf":[{"type":"integer"},{"type":"string"}],"description":"Port is the port of the ServicePort.","x-kubernetes-int-or-string":true}},"required":["name","port"],"type":"object"},"targetGroupARN":{"description":"targetGroupARN is the Amazon Resource Name (ARN) for the TargetGroup.","minLength":1,"type":"string"},"targetType":{"description":"targetType is the TargetType of TargetGroup. If unspecified, it will be automatically inferred.","enum":["instance","ip"],"type":"string"}},"required":["serviceRef","targetGroupARN"],"type":"object"},"status":{"description":"TargetGroupBindingStatus defines the observed state of TargetGroupBinding","properties":{"observedGeneration":{"description":"The generation observed by the TargetGroupBinding controller.","format":"int64","type":"integer"}},"type":"object"}},"type":"object"}},"served":true,"storage":true,"subresources":{"status":{}}}]},"status":{"acceptedNames":{"kind":"","plural":""},"conditions":[],"storedVersions":[]}}" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"apiextensions.k8s.io/v1","kind":"CustomResourceDefinition","metadata":{"annotations":{"controller-gen.kubebuilder.io/version":"v0.9.0"},"creationTimestamp":null,"name":"awsloadbalancercontrollers.networking.olm.openshift.io"},"spec":{"group":"networking.olm.openshift.io","names":{"kind":"AWSLoadBalancerController","listKind":"AWSLoadBalancerControllerList","plural":"awsloadbalancercontrollers","singular":"awsloadbalancercontroller"},"scope":"Cluster","versions":[{"name":"v1alpha1","schema":{"openAPIV3Schema":{"description":"AWSLoadBalancerController is the Schema for the awsloadbalancercontrollers API","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"AWSLoadBalancerControllerSpec defines the desired state of AWSLoadBalancerController","properties":{"additionalResourceTags":{"additionalProperties":{"type":"string"},"description":"Default AWS Tags that will be applied to all AWS resources managed by this controller (default []). \n This value is required so that this controller can function as expected in parallel to openshift-router.","type":"object"},"config":{"description":"Config specifies further customization options for the controller's deployment spec.","properties":{"replicas":{"default":2,"format":"int32","type":"integer"}},"type":"object"},"enabledAddons":{"description":"AWSAddon describes the AWS services that can be integrated with the AWS Load Balancer.","items":{"enum":["AWSShield","AWSWAFv1","AWSWAFv2"],"type":"string"},"type":"array"},"ingressClass":{"default":"alb","description":"IngressClass specifies the Ingress class which the controller will reconcile. This Ingress class will be created unless it already exists. The value will default to \"alb\".","type":"string"},"subnetTagging":{"default":"Auto","description":"SubnetTagging describes how resource tagging will be done by the operator. \n When in \"Auto\", the operator will detect the subnets where the load balancers will be provisioned and have the required resource tags on them. Whereas when set to manual, this responsibility lies on the user.","enum":["Auto","Manual"],"type":"string"}},"type":"object"},"status":{"description":"AWSLoadBalancerControllerStatus defines the observed state of AWSLoadBalancerController.","properties":{"conditions":{"description":"Conditions is a list of operator-specific conditions and their status.","items":{"description":"Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions.  For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }","properties":{"lastTransitionTime":{"description":"lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.","format":"date-time","type":"string"},"message":{"description":"message is a human readable message indicating details about the transition. This may be an empty string.","maxLength":32768,"type":"string"},"observedGeneration":{"description":"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.","format":"int64","minimum":0,"type":"integer"},"reason":{"description":"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.","maxLength":1024,"minLength":1,"pattern":"^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$","type":"string"},"status":{"description":"status of the condition, one of True, False, Unknown.","enum":["True","False","Unknown"],"type":"string"},"type":{"description":"type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)","maxLength":316,"pattern":"^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$","type":"string"}},"required":["lastTransitionTime","message","reason","status","type"],"type":"object"},"type":"array"},"ingressClass":{"description":"IngressClass is the current default Ingress class.","type":"string"},"observedGeneration":{"description":"ObservedGeneration is the most recent generation observed.","format":"int64","type":"integer"},"subnets":{"description":"Subnets contains details of the subnets of the cluster","properties":{"internal":{"description":"Internal is the list of subnet ids which have the tag `kubernetes.io/role/internal-elb`","items":{"type":"string"},"type":"array"},"public":{"description":"Public is the list of subnet ids which have the tag `kubernetes.io/role/elb`","items":{"type":"string"},"type":"array"},"subnetTagging":{"description":"SubnetTagging indicates the current status of the subnet tags","enum":["Auto","Manual"],"type":"string"},"tagged":{"description":"Tagged is the list of subnet ids which have been tagged by the operator","items":{"type":"string"},"type":"array"},"untagged":{"description":"Untagged is the list of subnet ids which do not have any role tags","items":{"type":"string"},"type":"array"}},"type":"object"}},"type":"object"}},"type":"object"}},"served":true,"storage":true,"subresources":{"status":{}}}]},"status":{"acceptedNames":{"kind":"","plural":""},"conditions":null,"storedVersions":null}}" + } + } + ], + "relatedImages": [ + { + "name": "controller", + "image": "registry.redhat.io/albo/aws-load-balancer-controller-rhel8@sha256:d7bc364512178c36671d8a4b5a76cf7cb10f8e56997106187b0fe1f032670ece" + }, + { + "name": "", + "image": "registry.redhat.io/albo/aws-load-balancer-operator-bundle@sha256:50b9402635dd4b312a86bed05dcdbda8c00120d3789ec2e9b527045100b3bdb4" + }, + { + "name": "aws-load-balancer-rhel8-operator-95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d-annotation", + "image": "registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d" + }, + { + "name": "manager", + "image": "registry.redhat.io/albo/aws-load-balancer-rhel8-operator@sha256:95c45fae0ca9e9bee0fa2c13652634e726d8133e4e3009b363fcae6814b3461d" + }, + { + "name": "kube-rbac-proxy", + "image": "registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:3658954f199040b0f244945c94955f794ee68008657421002e1b32962e7c30fc" + } + ] +} diff --git a/pkg/cli/mirror/testdata/single/testonly/configs/node-observability-operator/catalog.json b/pkg/cli/mirror/testdata/single/testonly/configs/node-observability-operator/catalog.json new file mode 100644 index 000000000..2a9882abf --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/configs/node-observability-operator/catalog.json @@ -0,0 +1,158 @@ +{ + "schema": "olm.package", + "name": "node-observability-operator", + "defaultChannel": "alpha", + "icon": { + "base64data": "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", + "mediatype": "image/png" + } +} +{ + "schema": "olm.channel", + "name": "alpha", + "package": "node-observability-operator", + "entries": [ + { + "name": "node-observability-operator.v0.1.0" + } + ] +} +{ + "schema": "olm.bundle", + "name": "node-observability-operator.v0.1.0", + "package": "node-observability-operator", + "image": "registry.redhat.io/noo/node-observability-operator-bundle-rhel8@sha256:25b8e1c8ed635364d4dcba7814ad504570b1c6053d287ab7e26c8d6a97ae3f6a", + "properties": [ + { + "type": "olm.gvk", + "value": { + "group": "nodeobservability.olm.openshift.io", + "kind": "NodeObservability", + "version": "v1alpha1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "nodeobservability.olm.openshift.io", + "kind": "NodeObservabilityMachineConfig", + "version": "v1alpha1" + } + }, + { + "type": "olm.gvk", + "value": { + "group": "nodeobservability.olm.openshift.io", + "kind": "NodeObservabilityRun", + "version": "v1alpha1" + } + }, + { + "type": "olm.package", + "value": { + "packageName": "node-observability-operator", + "version": "0.1.0" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm1ldGFkYXRhIjp7Im5hbWUiOiJwcm94eS1yb2xlIn0sInJ1bGVzIjpbeyJhcGlHcm91cHMiOlsiYXV0aGVudGljYXRpb24uazhzLmlvIl0sInJlc291cmNlcyI6WyJ0b2tlbnJldmlld3MiXSwidmVyYnMiOlsiY3JlYXRlIl19LHsiYXBpR3JvdXBzIjpbImF1dGhvcml6YXRpb24uazhzLmlvIl0sInJlc291cmNlcyI6WyJzdWJqZWN0YWNjZXNzcmV2aWV3cyJdLCJ2ZXJicyI6WyJjcmVhdGUiXX1dfQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZUJpbmRpbmciLCJtZXRhZGF0YSI6eyJuYW1lIjoicHJveHktcm9sZWJpbmRpbmcifSwicm9sZVJlZiI6eyJhcGlHcm91cCI6InJiYWMuYXV0aG9yaXphdGlvbi5rOHMuaW8iLCJraW5kIjoiQ2x1c3RlclJvbGUiLCJuYW1lIjoicHJveHktcm9sZSJ9LCJzdWJqZWN0cyI6W3sia2luZCI6IlNlcnZpY2VBY2NvdW50IiwibmFtZSI6ImNvbnRyb2xsZXItbWFuYWdlciIsIm5hbWVzcGFjZSI6InN5c3RlbSJ9XX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJraW5kIjoiU2VydmljZSIsIm1ldGFkYXRhIjp7ImxhYmVscyI6eyJjb250cm9sLXBsYW5lIjoiY29udHJvbGxlci1tYW5hZ2VyIn0sIm5hbWUiOiJjb250cm9sbGVyLW1hbmFnZXItbWV0cmljcy1zZXJ2aWNlIn0sInNwZWMiOnsicG9ydHMiOlt7Im5hbWUiOiJodHRwcyIsInBvcnQiOjg0NDMsInByb3RvY29sIjoiVENQIiwidGFyZ2V0UG9ydCI6Imh0dHBzIn1dLCJzZWxlY3RvciI6eyJjb250cm9sLXBsYW5lIjoiY29udHJvbGxlci1tYW5hZ2VyIn19fQ==" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJraW5kIjoiU2VydmljZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJsYWJlbHMiOnsiY29udHJvbC1wbGFuZSI6ImNvbnRyb2xsZXItbWFuYWdlciJ9LCJuYW1lIjoibm9kZS1vYnNlcnZhYmlsaXR5LW9wZXJhdG9yLWNvbnRyb2xsZXItbWFuYWdlci1tZXRyaWNzLXNlcnZpY2UifSwic3BlYyI6eyJwb3J0cyI6W3sibmFtZSI6Imh0dHBzIiwicG9ydCI6ODQ0MywicHJvdG9jb2wiOiJUQ1AiLCJ0YXJnZXRQb3J0IjoiaHR0cHMifV0sInNlbGVjdG9yIjp7ImNvbnRyb2wtcGxhbmUiOiJjb250cm9sbGVyLW1hbmFnZXIifX0sInN0YXR1cyI6eyJsb2FkQmFsYW5jZXIiOnt9fX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoidjEiLCJkYXRhIjp7ImNvbnRyb2xsZXJfbWFuYWdlcl9jb25maWcueWFtbCI6ImFwaVZlcnNpb246IGNvbnRyb2xsZXItcnVudGltZS5zaWdzLms4cy5pby92MWFscGhhMVxua2luZDogQ29udHJvbGxlck1hbmFnZXJDb25maWdcbmhlYWx0aDpcbiAgaGVhbHRoUHJvYmVCaW5kQWRkcmVzczogOjgwODFcbm1ldHJpY3M6XG4gIGJpbmRBZGRyZXNzOiAxMjcuMC4wLjE6ODA4MFxud2ViaG9vazpcbiAgcG9ydDogOTQ0M1xubGVhZGVyRWxlY3Rpb246XG4gIGxlYWRlckVsZWN0OiB0cnVlXG4gIHJlc291cmNlTmFtZTogOTRjNzM1YjYub2xtLm9wZW5zaGlmdC5pb1xuIn0sImtpbmQiOiJDb25maWdNYXAiLCJtZXRhZGF0YSI6eyJuYW1lIjoibm9kZS1vYnNlcnZhYmlsaXR5LW9wZXJhdG9yLW1hbmFnZXItY29uZmlnIn19" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJSb2xlIiwibWV0YWRhdGEiOnsiY3JlYXRpb25UaW1lc3RhbXAiOm51bGwsIm5hbWUiOiJub2RlLW9ic2VydmFiaWxpdHktb3BlcmF0b3ItbWFuYWdlci1yb2xlIn0sInJ1bGVzIjpbeyJhcGlHcm91cHMiOlsiYXBwcyJdLCJyZXNvdXJjZXMiOlsiZGFlbW9uc2V0cyJdLCJ2ZXJicyI6WyJjcmVhdGUiLCJnZXQiLCJsaXN0Iiwid2F0Y2giXX0seyJhcGlHcm91cHMiOlsiIl0sInJlc291cmNlcyI6WyJjb25maWdtYXBzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ1cGRhdGUiLCJ3YXRjaCJdfSx7ImFwaUdyb3VwcyI6WyIiXSwicmVzb3VyY2VzIjpbInNlY3JldHMiXSwidmVyYnMiOlsiY3JlYXRlIiwiZGVsZXRlIiwiZ2V0IiwibGlzdCIsIndhdGNoIl19LHsiYXBpR3JvdXBzIjpbIiJdLCJyZXNvdXJjZXMiOlsic2VydmljZWFjY291bnRzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ3YXRjaCJdfSx7ImFwaUdyb3VwcyI6WyIiXSwicmVzb3VyY2VzIjpbInNlcnZpY2VzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ3YXRjaCJdfSx7ImFwaUdyb3VwcyI6WyJyYmFjLmF1dGhvcml6YXRpb24uazhzLmlvIl0sInJlc291cmNlcyI6WyJyb2xlYmluZGluZ3MiXSwidmVyYnMiOlsiY3JlYXRlIiwiZGVsZXRlIiwiZ2V0IiwibGlzdCIsIndhdGNoIl19LHsiYXBpR3JvdXBzIjpbInJiYWMuYXV0aG9yaXphdGlvbi5rOHMuaW8iXSwicmVzb3VyY2VzIjpbInJvbGVzIl0sInZlcmJzIjpbImNyZWF0ZSIsImRlbGV0ZSIsImdldCIsImxpc3QiLCJ3YXRjaCJdfV19" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm1ldGFkYXRhIjp7ImNyZWF0aW9uVGltZXN0YW1wIjpudWxsLCJuYW1lIjoibm9kZS1vYnNlcnZhYmlsaXR5LW9wZXJhdG9yLW1ldHJpY3MtcmVhZGVyIn0sInJ1bGVzIjpbeyJub25SZXNvdXJjZVVSTHMiOlsiL21ldHJpY3MiXSwidmVyYnMiOlsiZ2V0Il19XX0=" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"annotations":{"alm-examples":"[\n  {\n    \"apiVersion\": \"nodeobservability.olm.openshift.io/v1alpha1\",\n    \"kind\": \"NodeObservability\",\n    \"metadata\": {\n      \"name\": \"cluster\"\n    },\n    \"spec\": {\n      \"labels\": {\n        \"node-role.kubernetes.io/worker\": \"\"\n      },\n      \"type\": \"crio-kubelet\"\n    }\n  },\n  {\n    \"apiVersion\": \"nodeobservability.olm.openshift.io/v1alpha1\",\n    \"kind\": \"NodeObservabilityMachineConfig\",\n    \"metadata\": {\n      \"name\": \"sample\"\n    },\n    \"spec\": {\n      \"debug\": {\n        \"enableCrioProfiling\": true\n      }\n    }\n  },\n  {\n    \"apiVersion\": \"nodeobservability.olm.openshift.io/v1alpha1\",\n    \"kind\": \"NodeObservabilityRun\",\n    \"metadata\": {\n      \"name\": \"nodeobservabilityrun-sample\",\n      \"namespace\": \"node-observability-operator\"\n    },\n    \"spec\": {\n      \"nodeObservabilityRef\": {\n        \"name\": \"cluster\"\n      }\n    }\n  }\n]","capabilities":"Basic Install","containerImage":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","createdAt":"2022-07-08T22:30:53","operatorframework.io/suggested-namespace":"node-observability-operator","operators.openshift.io/valid-subscription":"[\"OpenShift Container Platform\"]","operators.operatorframework.io/builder":"operator-sdk-v1.18.0+git","operators.operatorframework.io/project_layout":"go.kubebuilder.io/v3"},"name":"node-observability-operator.v0.1.0","namespace":"placeholder"},"spec":{"apiservicedefinitions":{},"customresourcedefinitions":{"owned":[{"description":"NodeObservability prepares a subset of worker nodes (identified by a label) for running node observability queries, such as profiling","displayName":"Node Observability","kind":"NodeObservability","name":"nodeobservabilities.nodeobservability.olm.openshift.io","version":"v1alpha1"},{"description":"NodeObservabilityMachineConfig is the Schema for the nodeobservabilitymachineconfigs API","displayName":"Node Observability Machine Config","kind":"NodeObservabilityMachineConfig","name":"nodeobservabilitymachineconfigs.nodeobservability.olm.openshift.io","version":"v1alpha1"},{"description":"NodeObservabilityRun is a request to run observability actions on the nodes previously selected in NodeObservability resource","displayName":"Node Observability Run","kind":"NodeObservabilityRun","name":"nodeobservabilityruns.nodeobservability.olm.openshift.io","version":"v1alpha1"}]},"description":"An Operator that will be able to gather debugging/profiling data over\na custom period of time which would be helpful to troubleshoot and resolve issues\nfor OpenShift customers.","displayName":"Node Observability Operator","icon":[{"base64data":"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","mediatype":"image/png"}],"install":{"spec":{"clusterPermissions":[{"rules":[{"nonResourceURLs":["/debug/*"],"verbs":["get"]},{"nonResourceURLs":["/node-observability-pprof"],"verbs":["get"]},{"nonResourceURLs":["/node-observability-status"],"verbs":["get"]},{"apiGroups":[""],"resources":["endpoints"],"verbs":["get","list","watch"]},{"apiGroups":[""],"resources":["events"],"verbs":["create"]},{"apiGroups":["authentication.k8s.io"],"resources":["tokenreviews"],"verbs":["create"]},{"apiGroups":["authorization.k8s.io"],"resources":["subjectaccessreviews"],"verbs":["create"]},{"apiGroups":[""],"resourceNames":["kubelet-serving-ca"],"resources":["configmaps"],"verbs":["get","list"]},{"apiGroups":[""],"resources":["nodes"],"verbs":["get","list","patch","watch"]},{"apiGroups":[""],"resources":["nodes/proxy"],"verbs":["get","list"]},{"apiGroups":[""],"resources":["pods"],"verbs":["get","list","watch"]},{"apiGroups":["machineconfiguration.openshift.io"],"resources":["machineconfigpools"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["machineconfiguration.openshift.io"],"resources":["machineconfigs"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilities"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilities/finalizers"],"verbs":["update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilities/status"],"verbs":["get","patch","update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilitymachineconfigs"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilitymachineconfigs/finalizers"],"verbs":["update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilitymachineconfigs/status"],"verbs":["get","patch","update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilityruns"],"verbs":["create","delete","get","list","patch","update","watch"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilityruns/finalizers"],"verbs":["update"]},{"apiGroups":["nodeobservability.olm.openshift.io"],"resources":["nodeobservabilityruns/status"],"verbs":["get","patch","update"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["clusterrolebindings"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["clusterroles"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["security.openshift.io"],"resources":["securitycontextconstraints"],"verbs":["create","delete","get","list","use","watch"]},{"apiGroups":["authentication.k8s.io"],"resources":["tokenreviews"],"verbs":["create"]},{"apiGroups":["authorization.k8s.io"],"resources":["subjectaccessreviews"],"verbs":["create"]}],"serviceAccountName":"node-observability-operator-controller-manager"}],"deployments":[{"label":{"control-plane":"controller-manager"},"name":"node-observability-operator-controller-manager","spec":{"replicas":1,"selector":{"matchLabels":{"control-plane":"controller-manager"}},"strategy":{},"template":{"metadata":{"annotations":{"kubectl.kubernetes.io/default-container":"manager"},"labels":{"control-plane":"controller-manager"}},"spec":{"containers":[{"args":["--secure-listen-address=0.0.0.0:8443","--upstream=http://127.0.0.1:8080/","--logtostderr=true","--v=10"],"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e","name":"kube-rbac-proxy","ports":[{"containerPort":8443,"name":"https","protocol":"TCP"}],"resources":{"limits":{"cpu":"20m","memory":"40Mi"},"requests":{"cpu":"10m","memory":"20Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]},"seccompProfile":{"type":"RuntimeDefault"}}},{"args":["--health-probe-bind-address=:8081","--metrics-bind-address=127.0.0.1:8080","--leader-elect","--zap-log-level=$(LOG_LEVEL)","--operator-namespace=$(OPERATOR_NAMESPACE)","--agent-image=$(RELATED_IMAGE_AGENT)"],"env":[{"name":"LOG_LEVEL","value":"info"},{"name":"OPERATOR_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.namespace"}}},{"name":"RELATED_IMAGE_AGENT","value":"registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc"}],"image":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","imagePullPolicy":"Always","livenessProbe":{"httpGet":{"path":"/healthz","port":8081},"initialDelaySeconds":15,"periodSeconds":20},"name":"manager","readinessProbe":{"httpGet":{"path":"/readyz","port":8081},"initialDelaySeconds":5,"periodSeconds":10},"resources":{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"10m","memory":"64Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"capabilities":{"drop":["ALL"]},"seccompProfile":{"type":"RuntimeDefault"}},"volumeMounts":[{"mountPath":"/var/run/secrets/openshift.io/certs","name":"ca-bundle"}]}],"securityContext":{"runAsNonRoot":true},"serviceAccountName":"node-observability-operator-controller-manager","terminationGracePeriodSeconds":10,"volumes":[{"configMap":{"items":[{"key":"service-ca.crt","path":"service-ca.crt"}],"name":"openshift-service-ca.crt"},"name":"ca-bundle"}]}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["configmaps"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":["coordination.k8s.io"],"resources":["leases"],"verbs":["get","list","watch","create","update","patch","delete"]},{"apiGroups":[""],"resources":["events"],"verbs":["create","patch"]},{"apiGroups":["apps"],"resources":["daemonsets"],"verbs":["create","get","list","watch"]},{"apiGroups":[""],"resources":["configmaps"],"verbs":["create","delete","get","list","update","watch"]},{"apiGroups":[""],"resources":["secrets"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":[""],"resources":["serviceaccounts"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":[""],"resources":["services"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["rolebindings"],"verbs":["create","delete","get","list","watch"]},{"apiGroups":["rbac.authorization.k8s.io"],"resources":["roles"],"verbs":["create","delete","get","list","watch"]}],"serviceAccountName":"node-observability-operator-controller-manager"}]},"strategy":"deployment"},"installModes":[{"supported":true,"type":"OwnNamespace"},{"supported":false,"type":"SingleNamespace"},{"supported":false,"type":"MultiNamespace"},{"supported":false,"type":"AllNamespaces"}],"keywords":["node-observability-operator"],"links":[{"name":"Source Code","url":"https://github.com/openshift/node-observability-operator"}],"maturity":"alpha","minKubeVersion":"1.23.0","provider":{"name":"Red Hat, Inc."},"relatedImages":[{"image":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","name":"node-observability-rhel8-operator-0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19-annotation"},{"image":"registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e","name":"kube-rbac-proxy"},{"image":"registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19","name":"manager"},{"image":"registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc","name":"agent"}],"version":"0.1.0"}}" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "eyJhcGlWZXJzaW9uIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pby92MSIsImtpbmQiOiJDbHVzdGVyUm9sZUJpbmRpbmciLCJtZXRhZGF0YSI6eyJuYW1lIjoibWFuYWdlci1yb2xlYmluZGluZyJ9LCJyb2xlUmVmIjp7ImFwaUdyb3VwIjoicmJhYy5hdXRob3JpemF0aW9uLms4cy5pbyIsImtpbmQiOiJDbHVzdGVyUm9sZSIsIm5hbWUiOiJtYW5hZ2VyLXJvbGUifSwic3ViamVjdHMiOlt7ImtpbmQiOiJTZXJ2aWNlQWNjb3VudCIsIm5hbWUiOiJjb250cm9sbGVyLW1hbmFnZXIiLCJuYW1lc3BhY2UiOiJzeXN0ZW0ifV19" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "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" + } + }, + { + "type": "olm.bundle.object", + "value": { + "data": "{"apiVersion":"apiextensions.k8s.io/v1","kind":"CustomResourceDefinition","metadata":{"annotations":{"controller-gen.kubebuilder.io/version":"v0.8.0"},"creationTimestamp":null,"name":"nodeobservabilityruns.nodeobservability.olm.openshift.io"},"spec":{"group":"nodeobservability.olm.openshift.io","names":{"kind":"NodeObservabilityRun","listKind":"NodeObservabilityRunList","plural":"nodeobservabilityruns","shortNames":["nobr"],"singular":"nodeobservabilityrun"},"scope":"Namespaced","versions":[{"additionalPrinterColumns":[{"jsonPath":".spec.nodeObservabilityRef.name","name":"NodeObservabilityRef","type":"string"}],"name":"v1alpha1","schema":{"openAPIV3Schema":{"description":"NodeObservabilityRun is a request to run observability actions on the nodes previously selected in NodeObservability resource","properties":{"apiVersion":{"description":"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources","type":"string"},"kind":{"description":"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds","type":"string"},"metadata":{"type":"object"},"spec":{"description":"NodeObservabilityRunSpec defines the desired state of NodeObservabilityRun","properties":{"nodeObservabilityRef":{"description":"NodeObservabilityRef is the reference to the parent NodeObservability resource","properties":{"name":{"description":"Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names","type":"string"}},"required":["name"],"type":"object"}},"required":["nodeObservabilityRef"],"type":"object"},"status":{"description":"NodeObservabilityRunStatus defines the observed state of NodeObservabilityRun","properties":{"agents":{"description":"Agents represents the list of Nodes that are included in this Run. Agents are Pods, and as such, not all are always ready/available","items":{"properties":{"ip":{"type":"string"},"name":{"type":"string"},"port":{"format":"int32","type":"integer"}},"type":"object"},"type":"array"},"conditions":{"description":"Conditions contain details for aspects of the current state of this API Resource.","properties":{"conditions":{"items":{"description":"Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions.  For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }","properties":{"lastTransitionTime":{"description":"lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.","format":"date-time","type":"string"},"message":{"description":"message is a human readable message indicating details about the transition. This may be an empty string.","maxLength":32768,"type":"string"},"observedGeneration":{"description":"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.","format":"int64","minimum":0,"type":"integer"},"reason":{"description":"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.","maxLength":1024,"minLength":1,"pattern":"^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$","type":"string"},"status":{"description":"status of the condition, one of True, False, Unknown.","enum":["True","False","Unknown"],"type":"string"},"type":{"description":"type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)","maxLength":316,"pattern":"^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$","type":"string"}},"required":["lastTransitionTime","message","reason","status","type"],"type":"object"},"type":"array"}},"type":"object"},"failedAgents":{"description":"FailedAgents represents the list of Nodes that could not be included in this Run This could be due to Node/Pod/Network failure","items":{"properties":{"ip":{"type":"string"},"name":{"type":"string"},"port":{"format":"int32","type":"integer"}},"type":"object"},"type":"array"},"finishedTimestamp":{"description":"FinishedTimestamp represents the server time when the NodeObservabilityRun finished. When not set, the NodeObservabilityRun isn't known to have finished. It is represented in RFC3339 form and is in UTC.","format":"date-time","type":"string"},"output":{"description":"Output is the output location of this NodeObservabilityRun When not set, no output location is known","type":"string"},"startTimestamp":{"description":"StartTimestamp represents the server time when the NodeObservabilityRun started. When not set, the NodeObservabilityRun hasn't started. It is represented in RFC3339 form and is in UTC.","format":"date-time","type":"string"}},"type":"object"}},"type":"object"}},"served":true,"storage":true,"subresources":{"status":{}}}]},"status":{"acceptedNames":{"kind":"","plural":""},"conditions":[],"storedVersions":[]}}" + } + } + ], + "relatedImages": [ + { + "name": "agent", + "image": "registry.redhat.io/noo/node-observability-agent-rhel8@sha256:59bd5b8cefae5d5769d33dafcaff083b583a552e1df61194a3cc078b75cb1fdc" + }, + { + "name": "", + "image": "registry.redhat.io/noo/node-observability-operator-bundle-rhel8@sha256:25b8e1c8ed635364d4dcba7814ad504570b1c6053d287ab7e26c8d6a97ae3f6a" + }, + { + "name": "node-observability-rhel8-operator-0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19-annotation", + "image": "registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19" + }, + { + "name": "manager", + "image": "registry.redhat.io/noo/node-observability-rhel8-operator@sha256:0040925e971e4bb3ac34278c3fb5c1325367fe41ad73641e6502ec2104bc4e19" + }, + { + "name": "kube-rbac-proxy", + "image": "registry.redhat.io/openshift4/ose-kube-rbac-proxy@sha256:bb54bc66185afa09853744545d52ea22f88b67756233a47b9f808fe59cda925e" + } + ] +} diff --git a/pkg/cli/mirror/testdata/single/testonly/grpc_health_probe b/pkg/cli/mirror/testdata/single/testonly/grpc_health_probe new file mode 100755 index 000000000..e69de29bb diff --git a/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/2243535a05266fa83c1b3765cd813829264ea6893485dbbfb78cca46830fc467 b/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/2243535a05266fa83c1b3765cd813829264ea6893485dbbfb78cca46830fc467 new file mode 100644 index 000000000..f77859f84 --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/2243535a05266fa83c1b3765cd813829264ea6893485dbbfb78cca46830fc467 @@ -0,0 +1 @@ +{"architecture":"amd64","config":{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],"Entrypoint":["/bin/opm"],"Cmd":["serve","/configs","--cache-dir=/tmp/cache"],"WorkingDir":"/","Labels":{"operators.operatorframework.io.index.configs.v1":"/configs"},"ArgsEscaped":true,"OnBuild":null},"created":"2023-03-14T04:32:54.320364564Z","history":[{"created":"2023-03-14T04:32:54.320364564Z","created_by":"ENTRYPOINT [\"/bin/opm\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-14T04:32:54.320364564Z","created_by":"CMD [\"serve\" \"/configs\" \"--cache-dir=/tmp/cache\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2023-03-14T04:32:54.320364564Z","created_by":"COPY / / # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2023-03-14T04:32:54.320364564Z","created_by":"LABEL operators.operatorframework.io.index.configs.v1=/configs","comment":"buildkit.dockerfile.v0","empty_layer":true}],"os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:6b8e95bc1d81301e5e6e35f8ab61d4a79722eec7e9cb828e7689d7f34128d48c"]}} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/584573fbd780c09f94829659b845261a4f9282882b02d27ea485acf95287dfa0 b/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/584573fbd780c09f94829659b845261a4f9282882b02d27ea485acf95287dfa0 new file mode 100644 index 000000000..ea9a576df Binary files /dev/null and b/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/584573fbd780c09f94829659b845261a4f9282882b02d27ea485acf95287dfa0 differ diff --git a/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/a0aae779d7da2bb33c2d06f49510a50ec612b8cd1fb81f6ff4625bde497289a3 b/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/a0aae779d7da2bb33c2d06f49510a50ec612b8cd1fb81f6ff4625bde497289a3 new file mode 100644 index 000000000..970f6732b --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/layout/blobs/sha256/a0aae779d7da2bb33c2d06f49510a50ec612b8cd1fb81f6ff4625bde497289a3 @@ -0,0 +1 @@ +{"schemaVersion":2,"mediaType":"application/vnd.docker.distribution.manifest.v2+json","config":{"mediaType":"application/vnd.docker.container.image.v1+json","size":1096,"digest":"sha256:2243535a05266fa83c1b3765cd813829264ea6893485dbbfb78cca46830fc467"},"layers":[{"mediaType":"application/vnd.docker.image.rootfs.diff.tar.gzip","size":81856,"digest":"sha256:584573fbd780c09f94829659b845261a4f9282882b02d27ea485acf95287dfa0"}]} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/single/testonly/layout/index.json b/pkg/cli/mirror/testdata/single/testonly/layout/index.json new file mode 100644 index 000000000..c196f1e77 --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/layout/index.json @@ -0,0 +1 @@ +{"schemaVersion":2,"manifests":[{"mediaType":"application/vnd.docker.distribution.manifest.v2+json","digest":"sha256:a0aae779d7da2bb33c2d06f49510a50ec612b8cd1fb81f6ff4625bde497289a3","size":426}]} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/single/testonly/layout/oci-layout b/pkg/cli/mirror/testdata/single/testonly/layout/oci-layout new file mode 100644 index 000000000..21b1439d1 --- /dev/null +++ b/pkg/cli/mirror/testdata/single/testonly/layout/oci-layout @@ -0,0 +1 @@ +{"imageLayoutVersion": "1.0.0"} \ No newline at end of file diff --git a/pkg/cli/mirror/testdata/single/testonly/opm b/pkg/cli/mirror/testdata/single/testonly/opm new file mode 100755 index 000000000..e69de29bb diff --git a/pkg/cli/options.go b/pkg/cli/options.go index 16c5d9e18..40d15649e 100644 --- a/pkg/cli/options.go +++ b/pkg/cli/options.go @@ -12,19 +12,21 @@ import ( "github.com/spf13/pflag" "k8s.io/cli-runtime/pkg/genericclioptions" "k8s.io/klog/v2" + + "github.com/openshift/oc-mirror/pkg/config" ) type RootOptions struct { genericclioptions.IOStreams - Dir string - LogLevel int + Dir string // Assets directory + LogLevel int // Number for the log level verbosity (valid 1-9, default is 0) logfileCleanup func() } func (o *RootOptions) BindFlags(fs *pflag.FlagSet) { - fs.StringVarP(&o.Dir, "dir", "d", "oc-mirror-workspace", "Assets directory") + fs.StringVarP(&o.Dir, "dir", "d", config.DefaultWorkspaceName, "Assets directory") fs.IntVarP(&o.LogLevel, "verbose", "v", o.LogLevel, "Number for the log level verbosity (valid 1-9, default is 0)") if err := fs.MarkHidden("dir"); err != nil { klog.Fatal(err.Error()) diff --git a/pkg/config/metadata.go b/pkg/config/metadata.go index 437f2d703..c97ba0734 100644 --- a/pkg/config/metadata.go +++ b/pkg/config/metadata.go @@ -4,7 +4,50 @@ import ( "path/filepath" ) +/* +Constants defined here refer to this workspace layout: + + /tmp/cwd/oc-mirror-workspace + ├── results-1675904745 + └── src + ├── catalogs + │ └── icr.io ─┐ + │ └── cpopen ├─ catalog path (one per catalog) + │ └── ibm-zcon-zosconnect-catalog │ + │ └── sha256:6f02ecef46020bcd21bdd24a01f435023d5fc3943972ef0d9769d5276e178e76 ─┘ + │ ├── include-config.gob <—— this represents v1alpha2.IncludeConfig for associated with index/index.json + │ ├── index <—— this represents a decl config for "single architecture image" image + │ │ │ (i.e. no multi arch use case) + │ │ └── index.json <—— Declarative Config + │ └── layout <—— OCI layout is capable of holding “manifest list” and “single architecture" images + │ ├── blobs + │ │ └── sha256 + │ │ ├── 01c6d5dcde3e9f2de758d794a77974600fe5e0b7a8c2ce2833eede2e8b25e7e5 + │ │ ├── 1cd0595314a53d179ddaf68761c9f40c4d9d1bcd3f692d1c005938dac2993db6 + │ │ ├── 1ff4ea896d6b958aa060e04eb090f70c563ad0650e6b362c1a1d67582acb3b8e + │ │ ├── 25d123725cf91c20b497ca9dae8e0a6e8dedd8fe64f83757f3b41f6ac447eac0 + │ │ ├── 2d55550cefe39606cc933a2ed1d242b3fd9a72d85e92a2c6b52b9623a6f4fe6a + │ │ ├── 34e12aa195bcd8366fbab95a242e8214ae959259bd0a1119c28d124f5799f502 + │ │ ├── 49a32e2e950732d5a638d5486968dcc3096f940a94811cfec99bd5a4f9e1ad49 + │ │ ├── 561bc8bee264b124ba5673e73ad36589abbecf0b15fb845ed9aab4e640989fbc + │ │ ├── 6672e188b9c3f7274b7ebf4498b34f951bc20ea86a8d72367eab363f1722d2ed + │ │ ├── 7062267a99d0149e4129843a9e3257b882920fb8554ec2068a264b37539768bc + │ │ ├── ae475359a3fb8fe5e3dff0626f0c788b94340416eb5c453339abc884ac86b671 + │ │ ├── b2dd6105dc025aa5c5e8b75e0b2d8a390951369801d049fc0de2586917a42772 + │ │ ├── c03c8f94bb495320bbe862bc69349dbdf9f2a29b83d5b344b3930890aaf89d7d + │ │ ├── dc1b9846d7994450e74b9cde2e621f8c1d98cdf1debd591db291785dd3fc6446 + │ │ └── f89d6e2463fc5fff8bba9e568ec28a6030076dbc412bd52dff6dbf2b5897a59d + │ ├── index.json + │ └── oci-layout + ├── charts + ├── publish + │ └── .metadata.json + ├── release-signatures + └── v2 +*/ const ( + // DefaultWorkspaceName defines the default value for the workspace if not provided by the user + DefaultWorkspaceName = "oc-mirror-workspace" // SourceDir is the directory that contains // all temporary data in the oc-mirror workspace. SourceDir = "src" diff --git a/pkg/image/association_builder.go b/pkg/image/association_builder.go index c5fdce9a5..58af189f7 100644 --- a/pkg/image/association_builder.go +++ b/pkg/image/association_builder.go @@ -5,7 +5,6 @@ import ( "errors" "fmt" "io/fs" - "io/ioutil" "os" "path/filepath" @@ -144,7 +143,7 @@ func associateLocalImageLayers(image, localRoot, dirRef, tagOrID, defaultTag str default: return nil, fmt.Errorf("expected symlink or regular file mode, got: %b", m) } - manifestBytes, err := ioutil.ReadFile(filepath.Clean(manifestPath)) + manifestBytes, err := os.ReadFile(filepath.Clean(manifestPath)) if err != nil { return nil, fmt.Errorf("error reading image manifest file: %v", err) } diff --git a/pkg/image/builder/image_builder.go b/pkg/image/builder/image_builder.go index ed2729c86..462aa89ee 100644 --- a/pkg/image/builder/image_builder.go +++ b/pkg/image/builder/image_builder.go @@ -16,6 +16,7 @@ import ( "github.com/google/go-containerregistry/pkg/v1/layout" "github.com/google/go-containerregistry/pkg/v1/match" "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/google/go-containerregistry/pkg/v1/partial" "github.com/google/go-containerregistry/pkg/v1/remote" "github.com/google/go-containerregistry/pkg/v1/tarball" "github.com/google/go-containerregistry/pkg/v1/types" @@ -54,10 +55,32 @@ func (b *ImageBuilder) init() { } } +/* +configUpdateFunc allows callers of ImageBuilder.Run to modify the *v1.ConfigFile argument as appropriate for +the circumstances. +*/ type configUpdateFunc func(*v1.ConfigFile) -// Run modifies and pushes the catalog image existing in an OCI layout. The image configuration will be updated -// with the required labels and any provided layers will be appended. +/* +Run modifies and pushes the catalog image existing in an OCI layout. The image configuration will be updated +with the required labels and any provided layers will be appended. + +# Arguments + +• ctx: a cancellation context + +• targetRef: a docker image reference + +• layoutPath: an OCI image layout path + +• update: an optional function that allows callers to modify the *v1.ConfigFile if necessary + +• layers: zero or more layers to add to the images discovered during processing + +# Returns + +error: non-nil on error, nil otherwise +*/ func (b *ImageBuilder) Run(ctx context.Context, targetRef string, layoutPath layout.Path, update configUpdateFunc, layers ...v1.Layer) error { b.init() var v2format bool @@ -80,30 +103,140 @@ func (b *ImageBuilder) Run(ctx context.Context, targetRef string, layoutPath lay if err != nil { return err } - idxManifest, err := idx.IndexManifest() + // make a copy of the original manifest for later + originalIdxManifest, err := idx.IndexManifest() + if err != nil { + return err + } + originalIdxManifest = originalIdxManifest.DeepCopy() + + // process the image index for updates to images discovered along the way + resultIdx, err := b.processImageIndex(ctx, idx, &v2format, update, targetRef, layers...) if err != nil { return err } + // Ensure the index media type is a docker manifest list + // if child manifests are docker V2 schema + if v2format { + resultIdx = mutate.IndexMediaType(resultIdx, types.DockerManifestList) + } + // get the hashes from the original manifest since we need to remove them + originalHashes := []v1.Hash{} + for _, desc := range originalIdxManifest.Manifests { + originalHashes = append(originalHashes, desc.Digest) + } + // write out the index, replacing the old value + err = layoutPath.ReplaceIndex(resultIdx, match.Digests(originalHashes...)) + if err != nil { + return err + } + // "Pull" the updated index + idx, err = layoutPath.ImageIndex() + if err != nil { + return err + } + // while it's entirely valid to have nested "manifest list" (i.e. an ImageIndex) within an OCI layout, + // this does NOT work for remote registries. So if we have those, then we need to get the nested + // ImageIndex and push that to the remote registry. In theory there could be any number of nested + // ImageIndexes, but in practice, there's only one level deep, and its a "singleton". + topLevelIndexManifest, err := idx.IndexManifest() + if err != nil { + return err + } + var imageIndexToPush v1.ImageIndex + for _, descriptor := range topLevelIndexManifest.Manifests { + if descriptor.MediaType.IsImage() { + // if we find an image, then this top level index can be used to push to remote registry + imageIndexToPush = idx + // no need to look any further + break + } else if descriptor.MediaType.IsIndex() { + // if we find an image index, we can push that to the remote registry + imageIndexToPush, err = idx.ImageIndex(descriptor.Digest) + if err != nil { + return err + } + // we're not going to look any deeper or look for other indexes at this level + break + } + } + // push to the remote + return remote.WriteIndex(tag, imageIndexToPush, b.RemoteOpts...) +} + +/* +processImageIndex is a recursive helper function that allows for traversal of the hierarchy of +parent/child indexes that can exist for a multi arch image. There's always +at least one index at the root since this is an OCI layout that we're dealing with. +In theory there can be "infinite levels" of "index indirection" for multi arch images, but typically +its only two levels deep (i.e. index.json itself which is level one, and the manifest list +defined in the blobs directory, which is level two). + +Each image that is encountered is updated using the update function (if provided) and whatever layers are provided. + +# Arguments + +• ctx: a cancellation context + +• idx: the "current" image index for this stage of recursion + +• v2format: a boolean used to keep track of the type of image we're dealing with. false means OCI media types +should be used and true means docker v2s2 media types should be used + +• update: an optional function that allows callers to modify the *v1.ConfigFile if necessary + +• targetRef: the docker image reference, which is only used for error reporting in this function + +• layers: zero or more layers to add to the images discovered during processing + +# Returns + +• v1.ImageIndex: The resulting image index after processing has completed. Will be nil if an error occurs, otherwise non-nil. + +• error: non-nil if an error occurs, nil otherwise +*/ +func (b *ImageBuilder) processImageIndex(ctx context.Context, idx v1.ImageIndex, v2format *bool, update configUpdateFunc, targetRef string, layers ...v1.Layer) (v1.ImageIndex, error) { + var resultIdx v1.ImageIndex + resultIdx = idx + idxManifest, err := idx.IndexManifest() + if err != nil { + return nil, err + } for _, manifest := range idxManifest.Manifests { + currentHash := *manifest.Digest.DeepCopy() switch manifest.MediaType { + case types.DockerManifestList, types.OCIImageIndex: + innerIdx, err := idx.ImageIndex(currentHash) + if err != nil { + return nil, err + } + // recursive call + processedIdx, err := b.processImageIndex(ctx, innerIdx, v2format, update, targetRef, layers...) + if err != nil { + return nil, err + } + resultIdx = processedIdx + // making an assumption here that at any given point in the parent/child + // hierarchy, there's only a single image index entry + return resultIdx, nil case types.DockerManifestSchema2: - v2format = true + *v2format = true case types.OCIManifestSchema1: - v2format = false + *v2format = false default: - return fmt.Errorf("image %q: unsupported manifest format %q", targetRef, manifest.MediaType) + return nil, fmt.Errorf("image %q: unsupported manifest format %q", targetRef, manifest.MediaType) } - img, err := layoutPath.Image(manifest.Digest) + img, err := idx.Image(currentHash) if err != nil { - return err + return nil, err } // Add new layers to image. // Ensure they have the right media type. var mt types.MediaType - if v2format { + if *v2format { mt = types.DockerLayer } else { mt = types.OCILayer @@ -114,51 +247,75 @@ func (b *ImageBuilder) Run(ctx context.Context, targetRef string, layoutPath lay } img, err = mutate.Append(img, additions...) if err != nil { - return err + return nil, err } if update != nil { // Update image config cfg, err := img.ConfigFile() if err != nil { - return err + return nil, err } update(cfg) img, err = mutate.Config(img, cfg.Config) if err != nil { - return err + return nil, err } } - var layoutOpts []layout.Option - if manifest.Platform != nil { - layoutOpts = append(layoutOpts, layout.WithPlatform(*manifest.Platform)) - } else { - //OCI workflow manifest.Platform is nil, to avoid failures in the OCI workflow the default amd64/linux is set here - pf := &v1.Platform{Architecture: "amd64", OS: "linux"} - layoutOpts = append(layoutOpts, layout.WithPlatform(*pf)) + desc, err := partial.Descriptor(img) + if err != nil { + return nil, err + } + + // if the platform is not set, we need to attempt to do something about that + if desc.Platform == nil { + if manifest.Platform != nil { + // use the value from the manifest + desc.Platform = manifest.Platform + } else { + if config, err := img.ConfigFile(); err != nil { + // we can't get the config file so fall back to linux/amd64 + desc.Platform = &v1.Platform{Architecture: "amd64", OS: "linux"} + } else { + // if one of the required values is missing, fall back to linux/amd64 + if config.Architecture == "" || config.OS == "" { + desc.Platform = &v1.Platform{Architecture: "amd64", OS: "linux"} + } else { + // use the value provided by the image config + desc.Platform = &v1.Platform{Architecture: config.Architecture, OS: config.OS} + } + } + } } - if err := layoutPath.ReplaceImage(img, match.Digests(manifest.Digest), layoutOpts...); err != nil { - return err + add := mutate.IndexAddendum{ + Add: img, + Descriptor: *desc, } + modifiedIndex := mutate.AppendManifests(mutate.RemoveManifests(resultIdx, match.Digests(currentHash)), add) + resultIdx = modifiedIndex } + return resultIdx, nil +} - // Pull updated index - idx, err = layoutPath.ImageIndex() - if err != nil { - return err - } +/* +CreateLayout will create an OCI image layout from an image or return +a layout path from an existing OCI layout. - // Ensure the index media type is a docker manifest list - // if child manifests are docker V2 schema - if v2format { - idx = mutate.IndexMediaType(idx, types.DockerManifestList) - } - return remote.WriteIndex(tag, idx, b.RemoteOpts...) -} +# Arguments + +• srcRef: if empty string, the dir argument is used for the layout.Path, otherwise +this value is used to pull an image into dir. + +• dir: a pre-populated OCI layout directory if srcRef is empty string, otherwise +this directory will be created + +# Returns + +• layout.Path: a OCI layout path if successful or an empty string if an error occurs -// CreateLayout will create an OCI image layout from an image or return -// a layout path from an existing OCI layout +• error: non-nil if an error occurs, nil otherwise +*/ func (b *ImageBuilder) CreateLayout(srcRef, dir string) (layout.Path, error) { b.init() if srcRef == "" { diff --git a/pkg/image/builder/image_builder_test.go b/pkg/image/builder/image_builder_test.go index 20a95adf6..3feaaa01f 100644 --- a/pkg/image/builder/image_builder_test.go +++ b/pkg/image/builder/image_builder_test.go @@ -2,8 +2,10 @@ package builder import ( "context" - "io/ioutil" + "net" + "net/http" "net/http/httptest" + "os" "path/filepath" "testing" @@ -75,6 +77,7 @@ func TestRun(t *testing.T) { pinToDigest bool update configUpdateFunc configAssertFunc func(cfg v1.ConfigFile) bool + multiarch bool // create a multi arch image err error }{ { @@ -100,15 +103,56 @@ func TestRun(t *testing.T) { pinToDigest: true, err: &ErrInvalidReference{}, }, + { + name: "Success/ExistingImage - multi arch", + existingImage: true, + multiarch: true, + }, + { + name: "Success/NewImage - multi arch", + existingImage: false, + multiarch: true, + }, + { + name: "Success/WithConfigUpdate - multi arch", + existingImage: true, + update: func(cfg *v1.ConfigFile) { + cfg.Config.Cmd = []string{"newcommand"} + }, + configAssertFunc: func(cfg v1.ConfigFile) bool { + return cfg.Config.Cmd[0] == "newcommand" + }, + multiarch: true, + }, + { + name: "Failure/DigestReference - multi arch", + pinToDigest: true, + err: &ErrInvalidReference{}, + multiarch: true, + }, + { + name: "Success/ExistingImage - multi arch with filter", + existingImage: true, + multiarch: true, + }, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { tmpdir := t.TempDir() + // each test case gets its own server server := httptest.NewServer(registry.New()) t.Cleanup(server.Close) - targetRef, err := testutils.WriteTestImage(server, tmpdir) + var targetRef string + var err error + if test.multiarch { + targetRef, err = testutils.WriteMultiArchTestImage(server, tmpdir) + // targetRef, err := testutils.WriteMultiArchTestImageWithURL("http://localhost:5000", tmpdir) + } else { + targetRef, err = testutils.WriteTestImage(server, tmpdir) + // targetRef, err := testutils.WriteTestImageWithURL("http://localhost:5000", tmpdir) + } require.NoError(t, err) if test.pinToDigest { @@ -117,7 +161,7 @@ func TestRun(t *testing.T) { } d1 := []byte("hello\ngo\n") - require.NoError(t, ioutil.WriteFile(filepath.Join(tmpdir, "test"), d1, 0644)) + require.NoError(t, os.WriteFile(filepath.Join(tmpdir, "test"), d1, 0644)) add, err := LayerFromPath("/testfile", filepath.Join(tmpdir, "test")) require.NoError(t, err) @@ -139,10 +183,90 @@ func TestRun(t *testing.T) { // Get new image information ref, err := name.ParseReference(targetRef, name.Insecure) require.NoError(t, err) - desc, err := remote.Get(ref) - require.NoError(t, err) - img, err := desc.Image() + /* + There's an important distinction between what's possible in OCI layout versus docker registries, + and you need to understand this when reading this test. The WriteMultiArchTestImage function + creates an OCI layout AND pushes to the dummy registry. + An OCI layout path contains an index.json where the manifest entries reference either a manifest list or an actual image. + Since the index.json is technically its own index, you can have "index indirection" where the manifest entry in index.json + points to a SHA within the blobs directory that is itself an "index". For example: + Single arch in an index.json + { + "schemaVersion": 2, + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "digest": "sha256:1234...", + "size": 111 + } + ] + } + multi arch with "indirection" in an index.json + { + "schemaVersion": 2, + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", + "digest": "sha256:5678...", + "size": 321 + } + ] + } + multi arch without "indirection" in an index.json (this scenario is probably not likely) + { + "schemaVersion": 2, + "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", + "manifests": [ + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "size": 525, + "digest": "sha256:9123...", + "platform": { + "architecture": "amd64", + "os": "linux" + } + }, + { + "mediaType": "application/vnd.docker.distribution.manifest.v2+json", + "size": 525, + "digest": "sha256:4567...", + "platform": { + "architecture": "s390x", + "os": "linux" + } + } + ] + } + However, in a "remote" docker registry, manifest indirection does not exist. So when reading + the descriptor from the "remote", we should expect to see a direct reference to either the + manifest list or image. + */ + var desc *remote.Descriptor + // make remote call to our dummy server to get its descriptor + desc, err = remote.Get(ref) require.NoError(t, err) + // figure out an image to test against + var img v1.Image + if test.multiarch { + require.True(t, desc.MediaType.IsIndex(), "expected a multi arch index") + idx, err := desc.ImageIndex() + require.NoError(t, err) + mf, err := idx.IndexManifest() + require.NoError(t, err) + for _, innerDescriptor := range mf.Manifests { + img, err = idx.Image(innerDescriptor.Digest) + require.NoError(t, err) + } + } else { + // single arch tests we can just get the image directly + // NOTE: WriteTestImage pushes an OCI image to the registry, so its technically a "manifest list" + // and the image is "resolved" using the platform associated with the image reference, or the default + // (i.e. linux/amd64) if platform is not present + img, err = desc.Image() + require.NoError(t, err) + } + // make sure we've actually found an image to work with + require.NotNil(t, img) layers, err := img.Layers() require.NoError(t, err) idx, err := desc.ImageIndex() @@ -162,7 +286,13 @@ func TestRun(t *testing.T) { } } require.True(t, found) - require.Len(t, im.Manifests, 1) + if test.multiarch { + // multi arch test has two manifests (linux/amd64 and linux/s390x) + require.Len(t, im.Manifests, 2) + } else { + // single arch test has a single image, so only one manifest + require.Len(t, im.Manifests, 1) + } if test.update != nil { config, err := img.ConfigFile() @@ -176,6 +306,19 @@ func TestRun(t *testing.T) { }) } } +func NewTestServerWithURL(URL string, handler http.Handler) (*httptest.Server, error) { + ts := httptest.NewUnstartedServer(handler) + if URL != "" { + l, err := net.Listen("tcp", URL) + if err != nil { + return nil, err + } + ts.Listener.Close() + ts.Listener = l + } + ts.Start() + return ts, nil +} func TestLayoutFromPath(t *testing.T) { @@ -203,7 +346,7 @@ func TestLayoutFromPath(t *testing.T) { // prep directory with files to write into layer d1 := []byte("hello\ngo\n") - require.NoError(t, ioutil.WriteFile(filepath.Join(tmpdir, "test"), d1, 0644)) + require.NoError(t, os.WriteFile(filepath.Join(tmpdir, "test"), d1, 0644)) var sourcePath string if test.dir { diff --git a/pkg/image/image.go b/pkg/image/image.go index 5c5344032..78c01e627 100644 --- a/pkg/image/image.go +++ b/pkg/image/image.go @@ -1,40 +1,31 @@ package image import ( - "context" "errors" "fmt" + "os" "strings" - "github.com/containers/image/v5/manifest" - "github.com/containers/image/v5/oci/layout" - "github.com/containers/image/v5/transports/alltransports" "github.com/google/go-containerregistry/pkg/authn" "github.com/google/go-containerregistry/pkg/name" + v1 "github.com/google/go-containerregistry/pkg/v1" + gcr "github.com/google/go-containerregistry/pkg/v1/layout" "github.com/google/go-containerregistry/pkg/v1/remote" - "github.com/openshift/library-go/pkg/image/reference" libgoref "github.com/openshift/library-go/pkg/image/reference" - "github.com/openshift/oc-mirror/pkg/api/v1alpha2" "github.com/openshift/oc/pkg/cli/image/imagesource" "k8s.io/klog/v2" + + "github.com/openshift/oc-mirror/pkg/api/v1alpha2" ) var ( DestinationOCI imagesource.DestinationType = "oci" ) -// type ImageReferenceInterface interface { -// String() string -// Equal(other ImageReferenceInterface) bool -// DockerClientDefaults() ImageReferenceInterface -// AsV2() ImageReferenceInterface -// Exact() string -// } - type TypedImageReference struct { - Type imagesource.DestinationType - Ref reference.DockerImageReference - OCIFBCPath string + Type imagesource.DestinationType // the destination type for this image + Ref libgoref.DockerImageReference // docker image reference (NOTE: if OCIFBCPath is not empty, this is just an approximation of a docker reference) + OCIFBCPath string // the path to the OCI layout on the file system. Will be empty string if reference is not OCI. } func (t TypedImageReference) String() string { @@ -94,6 +85,7 @@ func ParseReference(ref string) (TypedImageReference, error) { dstType := DestinationOCI + // Take the reference and convert it into a docker image reference. reg, ns, name, tag, id := v1alpha2.ParseImageReference(ref) dst := libgoref.DockerImageReference{ Registry: reg, @@ -103,45 +95,117 @@ func ParseReference(ref string) (TypedImageReference, error) { ID: id, } - // TODO if manifest does not exist , just do nothing - // in case of TargetName and TargetTag replacing the original name , - // the returned path will not exist on disk - manifest, err := getManifest(context.Background(), ref) - if err == nil { - dst.ID = string(manifest.ConfigInfo().Digest) + // Because this docker reference is based on a path to the OCI layout + // we need to convert the name and namespace to lower case to comply with the + // docker reference spec (see https://github.com/distribution/distribution/blob/main/reference/reference.go). + // Failure to do this will result in parsing errors for some docker reference parsers that + // perform strict validation. + // Example: when "ref" is oci:///Users/bob/temp/ocmirror the uppercase U will cause parsing errors. + dst.Name = strings.ToLower(dst.Name) + dst.Namespace = strings.ToLower(dst.Namespace) + + // if manifest does not exist (in case of TargetName and TargetTag replacing the original name, + // the returned path will not exist on disk), invalidate the ID since parsing the path + // to the OCI layout won't mean anything, and you'll likely get bogus + // information for the ID + digest, err := getFirstDigestFromPath(ref) + if err != nil { + // invalidate the ID + dst.ID = "" + + if errors.Is(err, os.ErrNotExist) { + // we know the error could be due to ref not pointing at a real directory + klog.V(1).Infof("path to oci layout does not exist (this is expected): %v", err) + } else { + // be noisy about this, but don't fail + klog.Infof("unexpected error encountered while getting digest from oci layout path: %v", err) + } + + } else { + dst.ID = digest.String() } return TypedImageReference{Ref: dst, Type: dstType, OCIFBCPath: ref}, nil } -// getManifest reads the manifest of the OCI FBC image -// and returns it as a go structure of type manifest.Manifest -func getManifest(ctx context.Context, imgPath string) (manifest.Manifest, error) { - imgRef, err := alltransports.ParseImageName(imgPath) +/* +getFirstDigestFromPath will inspect a OCI layout path provided by +the ref argument and return the **first available digest** within the layout. + +- If this layout stores a multi arch image, it returns the SHA of the manifest list itself. +This handles the case where index.json directly references a multi arch image +as well when a manifest list is indirectly referenced in the blobs directory. + +- If this layout stores a single arch image, it returns the SHA of the image manifest. + +This function will error when: + +- the index.json has no manifests + +- the index.json has more than one manifest (assuming that the index is not directly +referencing a multi arch image as described above) + +- other unexpected errors encountered during processing +*/ +func getFirstDigestFromPath(ref string) (*v1.Hash, error) { + filepath := v1alpha2.TrimProtocol(ref) + layoutPath, err := gcr.FromPath(filepath) if err != nil { - return nil, fmt.Errorf("unable to parse reference %s: %v", imgPath, err) + return nil, err } - imgsrc, err := imgRef.NewImageSource(ctx, nil) - defer func() { - if imgsrc != nil { - err = imgsrc.Close() - if err != nil { - klog.V(3).Infof("%s is not closed", imgsrc) - } - } - }() + ii, err := layoutPath.ImageIndex() if err != nil { - if err == layout.ErrMoreThanOneImage { - return nil, errors.New("multiple catalogs in the same location is not supported: https://github.com/openshift/oc-mirror/blob/main/TROUBLESHOOTING.md#error-examples") - } - return nil, fmt.Errorf("unable to create ImageSource for %s: %v", err, imgPath) + return nil, err } - manifestBlob, manifestType, err := imgsrc.GetManifest(ctx, nil) + + idxManifest, err := ii.IndexManifest() if err != nil { - return nil, fmt.Errorf("unable to get manifest blob from image : %w", err) + return nil, err } - manifest, err := manifest.FromBlob(manifestBlob, manifestType) - if err != nil { - return nil, fmt.Errorf("unable to unmarshall manifest of image : %w", err) + + // Handle use case where the index.json does not use + // indirection to point at a manifest list in the blobs directory. + // Do this by looking at the media type... its normally not present + // but when it is, this is a direct reference to the manifest list. + if idxManifest.MediaType.IsIndex() { + hash, err := ii.Digest() + if err != nil { + return nil, err + } + return &hash, nil + } + + // if manifest has more than one entry, throw error + if len(idxManifest.Manifests) > 1 { + return nil, fmt.Errorf("more than one image reference found in OCI layout %s, which usually indicates multiple images are being stored in the layout", ref) + } + + // grab the first manifest and return its digest + // using range here despite the prior length check for safety + // because we could have zero or one entries + for _, descriptor := range idxManifest.Manifests { + if descriptor.MediaType.IsImage() { + // if its an image, make sure it can be obtained + img, err := ii.Image(descriptor.Digest) + if err != nil { + // this is unlikely to happen but if it does, move on to the next item + continue + } + _, err = img.ConfigFile() + if err != nil { + // this is unlikely to happen but if it does, move on to the next item + continue + } + return &descriptor.Digest, nil + } else if descriptor.MediaType.IsIndex() { + // if its an image index, make sure it can be obtained + _, err := ii.ImageIndex(descriptor.Digest) + if err != nil { + // this is unlikely to happen but if it does, move on to the next item + continue + } + // return the digest for the manifest list + return &descriptor.Digest, nil + } } - return manifest, nil + return nil, fmt.Errorf("OCI layout %s did not contain any usable manifest entries", ref) } diff --git a/pkg/image/image_test.go b/pkg/image/image_test.go index e748f284e..ee5a892d9 100644 --- a/pkg/image/image_test.go +++ b/pkg/image/image_test.go @@ -1,8 +1,10 @@ package image import ( + "path/filepath" "testing" + v1 "github.com/google/go-containerregistry/pkg/v1" "github.com/openshift/library-go/pkg/image/reference" "github.com/openshift/oc-mirror/pkg/api/v1alpha2" "github.com/openshift/oc/pkg/cli/image/imagesource" @@ -116,3 +118,189 @@ func TestParseImageName(t *testing.T) { }) } } +func TestV1A2ParseImageReferenceOCIRefs(t *testing.T) { + type spec struct { + desc string + imageName string + expReg string + expOrg string + expRepo string + expTag string + expDigest string + } + cases := []spec{ + { + desc: "no path at all", + imageName: "oci:", + expReg: "", + expOrg: "", + expRepo: "", + expDigest: "", + expTag: "", + }, + { + desc: "single dir at relative path", + imageName: "oci://foo", + expReg: "", + expOrg: "", + expRepo: "foo", + expDigest: "", + expTag: "", + }, + { + desc: "no dir relative path", + imageName: "oci://", + expReg: "", + expOrg: "", + expRepo: "", + expDigest: "", + expTag: "", + }, + { + desc: "two levels deep at relative path", + imageName: "oci://foo/bar", + expReg: "foo", + expOrg: "", + expRepo: "bar", + expDigest: "", + expTag: "", + }, + { + desc: "three levels deep at relative path", + imageName: "oci://foo/bar/baz", + expReg: "foo", + expOrg: "bar", + expRepo: "baz", + expDigest: "", + expTag: "", + }, + { + desc: "three levels deep at relative path", + imageName: "oci://foo/bar/baz/blah", + expReg: "foo", + expOrg: "bar/baz", + expRepo: "blah", + expDigest: "", + expTag: "", + }, + { + desc: "no dir at root", + imageName: "oci:///", + expReg: "", + expOrg: "", + expRepo: "", + expDigest: "", + expTag: "", + }, + { + desc: "single dir at root", + imageName: "oci:///foo", + expReg: "", + expOrg: "", + expRepo: "foo", + expDigest: "", + expTag: "", + }, + { + desc: "two levels deep at root", + imageName: "oci:///foo/bar", + expReg: "foo", + expOrg: "", + expRepo: "bar", + expDigest: "", + expTag: "", + }, + { + desc: "three levels deep at root", + imageName: "oci:///foo/bar/baz", + expReg: "foo", + expOrg: "bar", + expRepo: "baz", + expDigest: "", + expTag: "", + }, + { + desc: "three levels deep at root", + imageName: "oci:///foo/bar/baz/blah", + expReg: "foo", + expOrg: "bar/baz", + expRepo: "blah", + expDigest: "", + expTag: "", + }, + } + for _, c := range cases { + t.Run(c.desc, func(t *testing.T) { + registry, org, repo, tag, sha := v1alpha2.ParseImageReference(c.imageName) + require.Equal(t, c.expReg, registry) + require.Equal(t, c.expOrg, org) + require.Equal(t, c.expRepo, repo) + require.Equal(t, c.expDigest, sha) + require.Equal(t, c.expTag, tag) + }) + } +} +func TestGetFirstDigestFromPath(t *testing.T) { + type spec struct { + desc string + inRef string + errorFunc require.ErrorAssertionFunc + expectedDigest *v1.Hash + } + makeRef := func(path string) string { + absPath, err := filepath.Abs(path) + require.NoError(t, err) + return v1alpha2.OCITransportPrefix + "//" + absPath + } + cases := []spec{ + { + desc: "single arch case one", + inRef: makeRef("../cli/mirror/testdata/artifacts/rhop-ctlg-oci"), + errorFunc: require.NoError, + expectedDigest: &v1.Hash{Algorithm: "sha256", Hex: "3986c6e039692ada9b5fa79ce51ce49bf6b24bc3af91d96e6c9d3d72f8077401"}, + }, + { + desc: "single arch case two", + inRef: makeRef("../cli/mirror/testdata/single/testonly/layout"), + errorFunc: require.NoError, + expectedDigest: &v1.Hash{Algorithm: "sha256", Hex: "a0aae779d7da2bb33c2d06f49510a50ec612b8cd1fb81f6ff4625bde497289a3"}, + }, + { + desc: "multi arch case one", + inRef: makeRef("../cli/mirror/testdata/manifestlist/hello"), + errorFunc: require.NoError, + expectedDigest: &v1.Hash{Algorithm: "sha256", Hex: "d0c9de6b9869c144aca831898c562d01169b740e50a73b8893cdd05ab94c64b7"}, + }, + { + desc: "multi arch case two", + inRef: makeRef("../cli/mirror/testdata/manifestlist/testonly/layout"), + errorFunc: require.NoError, + expectedDigest: &v1.Hash{Algorithm: "sha256", Hex: "f8859996f481d0332f486fca612ac64f4fc31b94d03f45086ed3e1aa3df3f5f7"}, + }, + { + desc: "multi arch case three - manifest at root", + inRef: makeRef("../cli/mirror/testdata/manifestlist/manifestlist-at-root/layout"), + errorFunc: require.NoError, + expectedDigest: &v1.Hash{Algorithm: "sha256", Hex: "f8859996f481d0332f486fca612ac64f4fc31b94d03f45086ed3e1aa3df3f5f7"}, + }, + { + desc: "nonexistent directory", + inRef: makeRef("foo"), + errorFunc: require.Error, + expectedDigest: nil, + }, + { + desc: "index is unmarshallable fails", + inRef: makeRef("../cli/mirror/testdata/artifacts/rhop-rotten-manifest"), + errorFunc: require.Error, + expectedDigest: nil, + }, + } + for _, c := range cases { + t.Run(c.desc, func(t *testing.T) { + actualDigest, err := getFirstDigestFromPath(c.inRef) + require.Equal(t, c.expectedDigest, actualDigest) + c.errorFunc(t, err) + }) + } +} diff --git a/pkg/metadata/store.go b/pkg/metadata/store.go index 48359f9ca..0c6aef573 100644 --- a/pkg/metadata/store.go +++ b/pkg/metadata/store.go @@ -4,7 +4,7 @@ import ( "context" "errors" "fmt" - "io/ioutil" + "io" "os" "path/filepath" @@ -63,7 +63,7 @@ func UpdateMetadata(ctx context.Context, backend storage.Backend, meta *v1alpha2 } logger := logrus.New() - logger.SetOutput(ioutil.Discard) + logger.SetOutput(io.Discard) nullLogger := logrus.NewEntry(logger) reg, err := containerdregistry.NewRegistry( diff --git a/vendor/github.com/google/go-containerregistry/pkg/v1/random/doc.go b/vendor/github.com/google/go-containerregistry/pkg/v1/random/doc.go new file mode 100644 index 000000000..d3712767d --- /dev/null +++ b/vendor/github.com/google/go-containerregistry/pkg/v1/random/doc.go @@ -0,0 +1,16 @@ +// Copyright 2018 Google LLC All Rights Reserved. +// +// 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 random provides a facility for synthesizing pseudo-random images. +package random diff --git a/vendor/github.com/google/go-containerregistry/pkg/v1/random/image.go b/vendor/github.com/google/go-containerregistry/pkg/v1/random/image.go new file mode 100644 index 000000000..6399412be --- /dev/null +++ b/vendor/github.com/google/go-containerregistry/pkg/v1/random/image.go @@ -0,0 +1,117 @@ +// Copyright 2018 Google LLC All Rights Reserved. +// +// 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 random + +import ( + "archive/tar" + "bytes" + "crypto/rand" + "crypto/sha256" + "encoding/hex" + "fmt" + "io" + "io/ioutil" + mrand "math/rand" + "time" + + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/empty" + "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/google/go-containerregistry/pkg/v1/partial" + "github.com/google/go-containerregistry/pkg/v1/types" +) + +// uncompressedLayer implements partial.UncompressedLayer from raw bytes. +type uncompressedLayer struct { + diffID v1.Hash + mediaType types.MediaType + content []byte +} + +// DiffID implements partial.UncompressedLayer +func (ul *uncompressedLayer) DiffID() (v1.Hash, error) { + return ul.diffID, nil +} + +// Uncompressed implements partial.UncompressedLayer +func (ul *uncompressedLayer) Uncompressed() (io.ReadCloser, error) { + return ioutil.NopCloser(bytes.NewBuffer(ul.content)), nil +} + +// MediaType returns the media type of the layer +func (ul *uncompressedLayer) MediaType() (types.MediaType, error) { + return ul.mediaType, nil +} + +var _ partial.UncompressedLayer = (*uncompressedLayer)(nil) + +// Image returns a pseudo-randomly generated Image. +func Image(byteSize, layers int64) (v1.Image, error) { + adds := make([]mutate.Addendum, 0, 5) + for i := int64(0); i < layers; i++ { + layer, err := Layer(byteSize, types.DockerLayer) + if err != nil { + return nil, err + } + adds = append(adds, mutate.Addendum{ + Layer: layer, + History: v1.History{ + Author: "random.Image", + Comment: fmt.Sprintf("this is a random history %d of %d", i, layers), + CreatedBy: "random", + Created: v1.Time{Time: time.Now()}, + }, + }) + } + + return mutate.Append(empty.Image, adds...) +} + +// Layer returns a layer with pseudo-randomly generated content. +func Layer(byteSize int64, mt types.MediaType) (v1.Layer, error) { + fileName := fmt.Sprintf("random_file_%d.txt", mrand.Int()) //nolint: gosec + + // Hash the contents as we write it out to the buffer. + var b bytes.Buffer + hasher := sha256.New() + mw := io.MultiWriter(&b, hasher) + + // Write a single file with a random name and random contents. + tw := tar.NewWriter(mw) + if err := tw.WriteHeader(&tar.Header{ + Name: fileName, + Size: byteSize, + Typeflag: tar.TypeRegA, + }); err != nil { + return nil, err + } + if _, err := io.CopyN(tw, rand.Reader, byteSize); err != nil { + return nil, err + } + if err := tw.Close(); err != nil { + return nil, err + } + + h := v1.Hash{ + Algorithm: "sha256", + Hex: hex.EncodeToString(hasher.Sum(make([]byte, 0, hasher.Size()))), + } + + return partial.UncompressedToLayer(&uncompressedLayer{ + diffID: h, + mediaType: mt, + content: b.Bytes(), + }) +} diff --git a/vendor/github.com/google/go-containerregistry/pkg/v1/random/index.go b/vendor/github.com/google/go-containerregistry/pkg/v1/random/index.go new file mode 100644 index 000000000..89a88438f --- /dev/null +++ b/vendor/github.com/google/go-containerregistry/pkg/v1/random/index.go @@ -0,0 +1,111 @@ +// Copyright 2018 Google LLC All Rights Reserved. +// +// 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 random + +import ( + "bytes" + "encoding/json" + "fmt" + + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/partial" + "github.com/google/go-containerregistry/pkg/v1/types" +) + +type randomIndex struct { + images map[v1.Hash]v1.Image + manifest *v1.IndexManifest +} + +// Index returns a pseudo-randomly generated ImageIndex with count images, each +// having the given number of layers of size byteSize. +func Index(byteSize, layers, count int64) (v1.ImageIndex, error) { + manifest := v1.IndexManifest{ + SchemaVersion: 2, + MediaType: types.OCIImageIndex, + Manifests: []v1.Descriptor{}, + } + + images := make(map[v1.Hash]v1.Image) + for i := int64(0); i < count; i++ { + img, err := Image(byteSize, layers) + if err != nil { + return nil, err + } + + rawManifest, err := img.RawManifest() + if err != nil { + return nil, err + } + digest, size, err := v1.SHA256(bytes.NewReader(rawManifest)) + if err != nil { + return nil, err + } + mediaType, err := img.MediaType() + if err != nil { + return nil, err + } + + manifest.Manifests = append(manifest.Manifests, v1.Descriptor{ + Digest: digest, + Size: size, + MediaType: mediaType, + }) + + images[digest] = img + } + + return &randomIndex{ + images: images, + manifest: &manifest, + }, nil +} + +func (i *randomIndex) MediaType() (types.MediaType, error) { + return i.manifest.MediaType, nil +} + +func (i *randomIndex) Digest() (v1.Hash, error) { + return partial.Digest(i) +} + +func (i *randomIndex) Size() (int64, error) { + return partial.Size(i) +} + +func (i *randomIndex) IndexManifest() (*v1.IndexManifest, error) { + return i.manifest, nil +} + +func (i *randomIndex) RawManifest() ([]byte, error) { + m, err := i.IndexManifest() + if err != nil { + return nil, err + } + return json.Marshal(m) +} + +func (i *randomIndex) Image(h v1.Hash) (v1.Image, error) { + if img, ok := i.images[h]; ok { + return img, nil + } + + return nil, fmt.Errorf("image not found: %v", h) +} + +func (i *randomIndex) ImageIndex(h v1.Hash) (v1.ImageIndex, error) { + // This is a single level index (for now?). + return nil, fmt.Errorf("image not found: %v", h) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index ec6966cd9..b11c09924 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -557,6 +557,7 @@ github.com/google/go-containerregistry/pkg/v1/layout github.com/google/go-containerregistry/pkg/v1/match github.com/google/go-containerregistry/pkg/v1/mutate github.com/google/go-containerregistry/pkg/v1/partial +github.com/google/go-containerregistry/pkg/v1/random github.com/google/go-containerregistry/pkg/v1/remote github.com/google/go-containerregistry/pkg/v1/remote/transport github.com/google/go-containerregistry/pkg/v1/stream