github.com/vchain-us/vcn@v0.9.11-0.20210921212052-a2484d23c0b3/pkg/bom/node/node.go

/*
 * Copyright (c) 2021 CodeNotary, Inc. All Rights Reserved.
 * This software is released under GPL3.
 * The full license information can be found under:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 */

package node

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path"
	"path/filepath"

	"github.com/opencontainers/go-digest"
	"github.com/vchain-us/vcn/pkg/bom/artifact"
	"github.com/vchain-us/vcn/pkg/bundle"
	"github.com/vchain-us/vcn/pkg/extractor/dir"
)

const packageLockJsonFN = "package-lock.json"
const packageJsonFN = "package.json"

const AssetType = "node"

type NodePackage struct {
	artifact.GenericArtifact
	pj string
}

func New(path string) artifact.Artifact {
	pj, err := GetPackageJsonPath(path)
	if err != nil {
		return nil
	}

	return &NodePackage{pj: pj}
}

func (p *NodePackage) ResolveDependencies(output artifact.OutputOptions) ([]artifact.Dependency, error) {
	if p.Deps != nil {
		return p.Deps, nil
	}

	if p.pj == "" {
		return nil, fmt.Errorf("package.json not found")
	}

	plj, err := getPackageLock(path.Dir(p.pj))
	if err != nil {
		return nil, fmt.Errorf("package-lock.json not found. Please run npm install")
	}

	comps := make([]artifact.Dependency, 0)
	fname, err := exec.LookPath("npm")
	if err != nil {
		return nil, fmt.Errorf("please install npm tool (7 version) follwing this link: https://docs.npmjs.com/getting-started. Error reported: %w", err)
	}

	ws := path.Dir(plj)
	command := exec.Command(fname, "ls", "-a", "-l", "-p", "--json")
	command.Dir = ws
	o, err := command.Output()
	if err != nil {
		switch e := err.(type) {
		case *exec.ExitError:
			if output == artifact.Debug {
				fmt.Printf("vcn encountered some problems while generating node BoM list. Result could be incomplete.\n%s\n", e.Stderr)
			}
		default:
			return nil, fmt.Errorf("%s: %w", ErrNpmParsingMsg, err)
		}
	}

	if o == nil {
		return nil, nil
	}

	var plJson map[string]interface{}

	err = json.Unmarshal(o, &plJson)
	if err != nil {
		return nil, err
	}

	dep, err := extractDependencies(plJson["dependencies"].(map[string]interface{}), output)
	if err != nil {
		return nil, err
	}

	comps = append(comps, dep...)

	p.Deps = comps
	return comps, nil
}

func extractDependencies(deps map[string]interface{}, output artifact.OutputOptions) ([]artifact.Dependency, error) {
	comps := make([]artifact.Dependency, 0)

	for _, dep := range deps {
		comp := artifact.Dependency{}
		d, ok := dep.(map[string]interface{})
		if !ok {
			warning(fmt.Sprintf("WARNING: impossible to calculate digest of %v dependency\n", dep), output)
			continue
		}
		if len(d) == 0 {
			continue
		}
		name, ok := d["name"].(string)
		if !ok {
			warning(fmt.Sprintf("WARNING: impossible to calculate digest of %v dependency\n", d), output)
			continue
		}
		version, ok := d["version"].(string)
		if !ok {
			warning(fmt.Sprintf("WARNING: impossible to calculate digest of %s dependency\n", name), output)
			continue
		}
		license, ok := d["license"].(string)
		if !ok {
			license = ""
		}
		nodeComPath, ok := d["path"].(string)
		if !ok {
			warning(fmt.Sprintf("WARNING: impossible to calculate digest of %s-%s dependency\n", name, version), output)
			continue
		}
		hash, err := GetNodeComDigest(nodeComPath)
		if err != nil {
			return nil, err
		}
		comp.Hash = hash.Encoded()
		comp.Version = version
		comp.Name = name
		comp.HashType = artifact.HashSHA256
		comp.License = license
		comps = append(comps, comp)
		if output == artifact.Debug {
			fmt.Printf("%s@%s (%s)\n", comp.Name, comp.Version, comp.Hash)
		}
	}
	return comps, nil
}

func getPackageLock(p string) (string, error) {
	fp := path.Join(p, packageLockJsonFN)
	_, err := os.Stat(fp)
	if err != nil {
		return "", err
	}
	return fp, nil
}

func (p *NodePackage) Type() string {
	return AssetType
}

func (p *NodePackage) Path() string {
	return p.pj
}

func (p *NodePackage) Close() {}

func GetPackageJsonPath(p string) (string, error) {
	fp := path.Join(p, packageJsonFN)
	_, err := os.Stat(fp)
	if err != nil {
		return "", err
	}
	return fp, nil
}

func GetNodeComDigest(componentFolder string) (digest.Digest, error) {
	path, err := filepath.Abs(componentFolder)
	if err != nil {
		return "", err
	}

	d, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer d.Close()

	stat, err := d.Stat()
	if err != nil {
		return "", err
	}
	if !stat.IsDir() {
		return "", fmt.Errorf("read node component %s: is not a directory", path)
	}

	files, err := dir.Walk(path)
	if err != nil {
		return "", err
	}

	manifest := bundle.NewManifest(files...)
	return manifest.Digest()
}

func warning(msg string, output artifact.OutputOptions) {
	if output != artifact.Silent {
		fmt.Print(msg)
	}
}