layer.go

/*
 * Copyright 2018-2020 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://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 libpak

import (
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"reflect"
	"time"

	"github.com/BurntSushi/toml"
	"github.com/heroku/color"

	"github.com/buildpacks/libcnb"

	"github.com/paketo-buildpacks/libpak/internal"
	"github.com/paketo-buildpacks/libpak/sbom"
	"github.com/paketo-buildpacks/libpak/sherpa"

	"github.com/paketo-buildpacks/libpak/bard"
)

// LayerContributor is a helper for implementing a libcnb.LayerContributor in order to get consistent logging and
// avoidance.
type LayerContributor struct {

	// ExpectedMetadata is the metadata to compare against any existing layer metadata.
	ExpectedMetadata interface{}

	// Logger is the logger to use.
	Logger bard.Logger

	// Name is the user readable name of the contribution.
	Name string

	// ExpectedTypes indicates the types that should be set on the layer.
	ExpectedTypes libcnb.LayerTypes
}

// NewLayerContributor creates a new instance.
func NewLayerContributor(name string, expectedMetadata interface{}, expectedTypes libcnb.LayerTypes) LayerContributor {
	return LayerContributor{
		ExpectedMetadata: expectedMetadata,
		Name:             name,
		ExpectedTypes:    expectedTypes,
	}
}

// LayerFunc is a callback function that is invoked when a layer needs to be contributed.
type LayerFunc func() (libcnb.Layer, error)

// Contribute is the function to call when implementing your libcnb.LayerContributor.
func (l *LayerContributor) Contribute(layer libcnb.Layer, f LayerFunc) (libcnb.Layer, error) {
	layerRestored, err := l.checkIfLayerRestored(layer)
	if err != nil {
		return libcnb.Layer{}, fmt.Errorf("unable to check metadata\n%w", err)
	}

	expected, cached, err := l.checkIfMetadataMatches(layer)
	if err != nil {
		return libcnb.Layer{}, fmt.Errorf("unable to check metadata\n%w", err)
	}

	if cached && layerRestored {
		l.Logger.Headerf("%s: %s cached layer", color.BlueString(l.Name), color.GreenString("Reusing"))
		layer.LayerTypes = l.ExpectedTypes
		return layer, nil
	}

	if !layerRestored {
		l.Logger.Headerf("%s: %s cached layer", color.BlueString(l.Name), color.RedString("Reloading"))
	} else {
		l.Logger.Headerf("%s: %s to layer", color.BlueString(l.Name), color.YellowString("Contributing"))
	}

	err = l.reset(layer)
	if err != nil {
		return libcnb.Layer{}, fmt.Errorf("unable to reset\n%w", err)
	}

	layer, err = f()
	if err != nil {
		return libcnb.Layer{}, err
	}

	layer.LayerTypes = l.ExpectedTypes
	layer.Metadata = expected

	return layer, nil
}

func (l *LayerContributor) checkIfMetadataMatches(layer libcnb.Layer) (map[string]interface{}, bool, error) {
	raw, err := internal.Marshal(l.ExpectedMetadata)
	if err != nil {
		return map[string]interface{}{}, false, fmt.Errorf("unable to encode metadata\n%w", err)
	}

	expected := map[string]interface{}{}
	if err := toml.Unmarshal(raw, &expected); err != nil {
		return map[string]interface{}{}, false, fmt.Errorf("unable to decode metadata\n%w", err)
	}

	l.Logger.Debugf("Expected metadata: %+v", expected)
	l.Logger.Debugf("Actual metadata: %+v", layer.Metadata)

	match, err := l.Equals(expected, layer.Metadata)
	if err != nil {
		return map[string]interface{}{}, false, fmt.Errorf("unable to compare metadata\n%w", err)
	}
	return expected, match, nil
}

func (l *LayerContributor) Equals(expectedM map[string]interface{}, layerM map[string]interface{}) (bool, error) {
	// TODO Do we want the Equals method to modify the underlying maps? Else we need to make a copy here.

	if err := l.normalizeDependencyDeprecationDate(expectedM); err != nil {
		return false, fmt.Errorf("%w (expected layer)", err)
	}

	if err := l.normalizeDependencyDeprecationDate(layerM); err != nil {
		return false, fmt.Errorf("%w (actual layer)", err)
	}

	return reflect.DeepEqual(expectedM, layerM), nil
}

// normalizeDependencyDeprecationDate makes sure the dependency deprecation date is represented as a time.Time object
// in the map whenever it exists.
func (l *LayerContributor) normalizeDependencyDeprecationDate(input map[string]interface{}) error {
	if dep, ok := input["dependency"].(map[string]interface{}); ok {
		for k, v := range dep {
			if k == "deprecation_date" {
				if err := l.replaceDeprecationDate(dep, v); err != nil {
					return err
				}
				break
			}
		}
	} else if depr_date, ok := input["deprecation_date"]; ok {
		if err := l.replaceDeprecationDate(input, depr_date); err != nil {
			return err
		}
	}

	return nil
}

func (l *LayerContributor) replaceDeprecationDate(metadata map[string]interface{}, value interface{}) error {
	deprecationDate, err := l.parseDeprecationDate(value)
	if err != nil {
		return err
	}
	metadata["deprecation_date"] = deprecationDate
	return nil
}

// parseDeprecationDate accepts both string and time.Time as input, and returns
// a truncated time.Time value.
func (l *LayerContributor) parseDeprecationDate(v interface{}) (deprecationDate time.Time, err error) {
	switch vDate := v.(type) {
	case time.Time:
		deprecationDate = vDate
	case string:
		deprecationDate, err = time.Parse(time.RFC3339, vDate)
		if err != nil {
			return time.Time{}, fmt.Errorf("unable to parse deprecation_date %s", vDate)
		}
	default:
		return time.Time{}, fmt.Errorf("unexpected type %T for deprecation_date %v", v, v)
	}

	deprecationDate = deprecationDate.Truncate(time.Second).In(time.UTC)
	return
}

func (l *LayerContributor) checkIfLayerRestored(layer libcnb.Layer) (bool, error) {
	layerTOML := fmt.Sprintf("%s.toml", layer.Path)
	tomlExists, err := sherpa.FileExists(layerTOML)
	if err != nil {
		return false, fmt.Errorf("unable to check if layer toml exists %s\n%w", layerTOML, err)
	}

	layerDirExists, err := sherpa.DirExists(layer.Path)
	if err != nil {
		return false, fmt.Errorf("unable to check if layer directory exists %s\n%w", layer.Path, err)
	}

	var dirContents []fs.DirEntry
	if layerDirExists {
		dirContents, err = os.ReadDir(layer.Path)
		if err != nil {
			return false, fmt.Errorf("unable to read directory %s\n%w", layer.Path, err)
		}
	}

	l.Logger.Debugf("Check If Layer Restored -> tomlExists: %s, layerDirExists: %s, dirContents: %s, cache: %s, build: %s",
		tomlExists, layerDirExists, dirContents, l.ExpectedTypes.Cache, l.ExpectedTypes.Build)
	return !(tomlExists && (!layerDirExists || len(dirContents) == 0) && (l.ExpectedTypes.Cache || l.ExpectedTypes.Build)), nil
}

func (l *LayerContributor) reset(layer libcnb.Layer) error {
	if err := os.RemoveAll(layer.Path); err != nil {
		return fmt.Errorf("unable to remove existing layer directory %s\n%w", layer.Path, err)
	}

	if err := os.MkdirAll(layer.Path, 0755); err != nil {
		return fmt.Errorf("unable to create layer directory %s\n%w", layer.Path, err)
	}

	return nil
}

// DependencyLayerContributor is a helper for implementing a libcnb.LayerContributor for a BuildpackDependency in order
// to get consistent logging and avoidance.
type DependencyLayerContributor struct {

	// Dependency is the dependency being contributed.
	Dependency BuildpackDependency

	// DependencyCache is the cache to use to get the dependency.
	DependencyCache DependencyCache

	// ExpectedTypes indicates the types that should be set on the layer.
	ExpectedTypes libcnb.LayerTypes

	// ExpectedMetadata contains metadata describing the expected layer
	ExpectedMetadata interface{}

	// Logger is the logger to use.
	Logger bard.Logger

	// RequestModifierFuncs is an optional Request Modifier to use when downloading the dependency.
	RequestModifierFuncs []RequestModifierFunc
}

// NewDependencyLayer returns a new DependencyLayerContributor for the given BuildpackDependency and a BOMEntry describing the layer contents.
//
// Deprecated: this method uses `libcnb.BOMEntry` which has been deprecated upstream, a future version will drop
// support for `libcnb.BOMEntry` which will change this method signature. Use NewDependencyLayerContributor instead.
func NewDependencyLayer(dependency BuildpackDependency, cache DependencyCache, types libcnb.LayerTypes) (DependencyLayerContributor, libcnb.BOMEntry) {
	dlc := NewDependencyLayerContributor(dependency, cache, types)

	entry := dependency.AsBOMEntry()
	entry.Metadata["layer"] = dlc.LayerName()

	if types.Launch {
		entry.Launch = true
	}
	if !(types.Launch && !types.Cache && !types.Build) {
		// launch-only layers are the only layers NOT guaranteed to be present in the build environment
		entry.Build = true
	}

	return dlc, entry
}

// NewDependencyLayerContributor returns a new DependencyLayerContributor for the given BuildpackDependency
func NewDependencyLayerContributor(dependency BuildpackDependency, cache DependencyCache, types libcnb.LayerTypes) DependencyLayerContributor {
	return DependencyLayerContributor{
		Dependency:       dependency,
		ExpectedMetadata: dependency,
		DependencyCache:  cache,
		ExpectedTypes:    types,
	}
}

// DependencyLayerFunc is a callback function that is invoked when a dependency needs to be contributed.
type DependencyLayerFunc func(artifact *os.File) (libcnb.Layer, error)

// Contribute is the function to call whe implementing your libcnb.LayerContributor.
func (d *DependencyLayerContributor) Contribute(layer libcnb.Layer, f DependencyLayerFunc) (libcnb.Layer, error) {
	lc := NewLayerContributor(d.Name(), d.ExpectedMetadata, d.ExpectedTypes)
	lc.Logger = d.Logger

	return lc.Contribute(layer, func() (libcnb.Layer, error) {
		artifact, err := d.DependencyCache.Artifact(d.Dependency, d.RequestModifierFuncs...)
		if err != nil {
			d.Logger.Debugf("fetching dependency %s failed\n%w", d.Dependency.Name, err)
			return libcnb.Layer{}, fmt.Errorf("unable to get dependency %s. see DEBUG log level", d.Dependency.Name)
		}
		defer artifact.Close()

		sbomArtifact, err := d.Dependency.AsSyftArtifact()
		if err != nil {
			return libcnb.Layer{}, fmt.Errorf("unable to get SBOM artifact %s\n%w", d.Dependency.ID, err)
		}

		sbomPath := layer.SBOMPath(libcnb.SyftJSON)
		dep := sbom.NewSyftDependency(layer.Path, []sbom.SyftArtifact{sbomArtifact})
		d.Logger.Debugf("Writing Syft SBOM at %s: %+v", sbomPath, dep)
		if err := dep.WriteTo(sbomPath); err != nil {
			return libcnb.Layer{}, fmt.Errorf("unable to write SBOM\n%w", err)
		}

		return f(artifact)
	})
}

// LayerName returns the conventional name of the layer for this contributor
func (d *DependencyLayerContributor) LayerName() string {
	return d.Dependency.ID
}

// Name returns the human readable name of the layer
func (d *DependencyLayerContributor) Name() string {
	return fmt.Sprintf("%s %s", d.Dependency.Name, d.Dependency.Version)
}

// HelperLayerContributor is a helper for implementing a libcnb.LayerContributor for a buildpack helper application in
// order to get consistent logging and avoidance.
type HelperLayerContributor struct {

	// Path is the path to the helper application.
	Path string

	// BuildpackInfo describes the buildpack that provides the helper
	BuildpackInfo libcnb.BuildpackInfo

	// Logger is the logger to use.
	Logger bard.Logger

	// Names are the names of the helpers to create
	Names []string
}

// NewHelperLayer returns a new HelperLayerContributor and a BOMEntry describing the layer contents.
//
// Deprecated: this method uses `libcnb.BOMEntry` which has been deprecated upstream, a future version will drop
// support for `libcnb.BOMEntry` which will change this method signature. Use NewHelperLayerContributor instead.
func NewHelperLayer(buildpack libcnb.Buildpack, names ...string) (HelperLayerContributor, libcnb.BOMEntry) {
	hl := NewHelperLayerContributor(buildpack, names...)

	return hl, libcnb.BOMEntry{
		Name: "helper",
		Metadata: map[string]interface{}{
			"layer":   hl.Name(),
			"names":   names,
			"version": buildpack.Info.Version,
		},
		Launch: true,
	}
}

// NewHelperLayerContributor returns a new HelperLayerContributor
func NewHelperLayerContributor(buildpack libcnb.Buildpack, names ...string) HelperLayerContributor {
	return HelperLayerContributor{
		Path:          filepath.Join(buildpack.Path, "bin", "helper"),
		Names:         names,
		BuildpackInfo: buildpack.Info,
	}
}

// Name returns the conventional name of the layer for this contributor
func (h HelperLayerContributor) Name() string {
	return filepath.Base(h.Path)
}

// Contribute is the function to call whe implementing your libcnb.LayerContributor.
func (h HelperLayerContributor) Contribute(layer libcnb.Layer) (libcnb.Layer, error) {
	expected := map[string]interface{}{"buildpackInfo": h.BuildpackInfo, "helperNames": h.Names}
	lc := NewLayerContributor("Launch Helper", expected, libcnb.LayerTypes{
		Launch: true,
	})

	lc.Logger = h.Logger

	return lc.Contribute(layer, func() (libcnb.Layer, error) {
		in, err := os.Open(h.Path)
		if err != nil {
			return libcnb.Layer{}, fmt.Errorf("unable to open %s\n%w", h.Path, err)
		}
		defer in.Close()

		out := filepath.Join(layer.Path, "helper")
		if err := sherpa.CopyFile(in, out); err != nil {
			return libcnb.Layer{}, fmt.Errorf("unable to copy %s to %s", h.Path, out)
		}

		for _, n := range h.Names {
			link := layer.Exec.FilePath(n)
			h.Logger.Bodyf("Creating %s", link)

			f := filepath.Dir(link)
			if err := os.MkdirAll(f, 0755); err != nil {
				return libcnb.Layer{}, fmt.Errorf("unable to create %s\n%w", f, err)
			}

			if err := os.Symlink(out, link); err != nil {
				return libcnb.Layer{}, fmt.Errorf("unable to link %s to %s\n%w", out, link, err)
			}
		}

		sbomArtifact, err := h.AsSyftArtifact()
		if err != nil {
			return libcnb.Layer{}, fmt.Errorf("unable to get SBOM artifact for helper\n%w", err)
		}

		sbomPath := layer.SBOMPath(libcnb.SyftJSON)
		dep := sbom.NewSyftDependency(layer.Path, []sbom.SyftArtifact{sbomArtifact})
		h.Logger.Debugf("Writing Syft SBOM at %s: %+v", sbomPath, dep)
		if err := dep.WriteTo(sbomPath); err != nil {
			return libcnb.Layer{}, fmt.Errorf("unable to write SBOM\n%w", err)
		}

		return layer, nil
	})
}

func (h HelperLayerContributor) AsSyftArtifact() (sbom.SyftArtifact, error) {
	licenses := []string{}
	for _, license := range h.BuildpackInfo.Licenses {
		licenses = append(licenses, license.Type)
	}

	locations := []sbom.SyftLocation{}
	cpes := []string{}
	for _, name := range h.Names {
		locations = append(locations, sbom.SyftLocation{Path: name})
		cpes = append(cpes, fmt.Sprintf("cpe:2.3:a:%s:%s:%s:*:*:*:*:*:*:*",
			h.BuildpackInfo.ID, name, h.BuildpackInfo.Version))
	}

	artifact := sbom.SyftArtifact{
		Name:      "helper",
		Version:   h.BuildpackInfo.Version,
		Type:      "UnknownPackage",
		FoundBy:   "libpak",
		Licenses:  licenses,
		Locations: locations,
		CPEs:      cpes,
		PURL:      fmt.Sprintf("pkg:generic/%s@%s", h.BuildpackInfo.ID, h.BuildpackInfo.Version),
	}
	var err error
	artifact.ID, err = artifact.Hash()
	if err != nil {
		return sbom.SyftArtifact{}, fmt.Errorf("unable to generate hash\n%w", err)
	}

	return artifact, nil
}