prereq.go - openserverless-cli - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you 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 openserverless

 import (
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"

 	"github.com/apache/openserverless-cli/tools"
 	"github.com/mitchellh/go-homedir"
 	"gopkg.in/yaml.v3"
 )

 var PrereqSeenMap = map[string]string{}

 // execute prereq task
 func execPrereqTask(bindir string, name string) error {
 	me, err := os.Executable()
 	if err != nil {
 		return err
 	}
 	args := []string{
 		"-task",
 		"-d", bindir,
 		"-t", PREREQ,
 		name,
 	}
 	if taskDryRun {
 		fmt.Printf("invoking prereq for %s\n", name)
 		return nil
 	}
 	trace("Exec:", me, args)
 	err = exec.Command(me, args...).Run()
 	if err != nil {
 		return err
 	}
 	return nil
 }

 // load prerequisites in current dir
 func loadPrereq(dir string) (tasks []string, versions []string, err error) {
 	err = nil
 	tasks = []string{}
 	versions = []string{}

 	if !exists(dir, PREREQ) {
 		return
 	}
 	trace("found prereq.yml in ", dir)

 	data, err := os.ReadFile(joinpath(dir, PREREQ))
 	if err != nil {
 		return
 	}

 	/*
 			You have tasks = []strings and versions = []strings
 			and dat a string with a YAML  in format:
 			```yaml
 			something:
 			tasks:
 			   task:
 			      vars:
 				     VERSION: "123"
 			   anothertask:
 		    ```
 			I want to parse the file, find the entries under `tasks` vith a var with  VERSION
 			and append, in order, to tasks the name of the task
 			and to version the version found
 			I have to skip the entries without a version and everyhing not in tasks
 			I wnato just the plain code no procedures
 	*/
 	var root yaml.Node
 	if err = yaml.Unmarshal([]byte(data), &root); err != nil {
 		return
 	}

 	for i := 0; i < len(root.Content[0].Content); i += 2 {
 		if root.Content[0].Content[i].Value == "tasks" {
 			tasksNode := root.Content[0].Content[i+1]
 			for j := 0; j < len(tasksNode.Content); j += 2 {
 				taskName := tasksNode.Content[j].Value
 				taskVars := tasksNode.Content[j+1]
 				for k := 0; k < len(taskVars.Content); k += 2 {
 					if taskVars.Content[k].Value == "vars" {
 						varsNode := taskVars.Content[k+1]
 						for l := 0; l < len(varsNode.Content); l += 2 {
 							if varsNode.Content[l].Value == "VERSION" {
 								version := varsNode.Content[l+1].Value
 								tasks = append(tasks, taskName)
 								versions = append(versions, version)
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 	return
 }

 func binDir() (string, error) {
 	var err error
 	bindir := os.Getenv("OPS_BIN")
 	if bindir == "" {
 		bindir, err = homedir.Expand(fmt.Sprintf("~/.ops/%s-%s/bin", tools.GetOS(), tools.GetARCH()))
 		if err != nil {
 			return "", err
 		}
 	}
 	os.Setenv("OPS_BIN", bindir)
 	return bindir, nil
 }

 func addExeExt(name string) string {
 	if tools.GetOS() == "windows" {
 		return name + ".exe"
 	}
 	return name
 }

 // ensure there is a bindir for downloading prerequisites
 // read it from OPS_BIN and create it
 // otherwise setup one in ~/ops/<os>-<arch>/bin
 // and sets OPS_BIN
 func EnsureBindir() (string, error) {
 	var err error = nil
 	bindir, err := binDir()
 	if err != nil {
 		return "", err
 	}
 	err = os.MkdirAll(bindir, 0755)
 	if err != nil {
 		return "", err
 	}
 	trace("bindir", bindir)
 	return bindir, nil
 }

 // create a mark of current version touching <name>-<version> and remove all the other files starting with <name>-
 func touchAndClean(dir string, name string, version string) error {

 	// Walk through the directory
 	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}

 		// Check if the file starts with the prefix
 		if !info.IsDir() && strings.HasPrefix(info.Name(), name+"-") {
 			trace("Removing file:", path)
 			err := os.Remove(path)
 			if err != nil {
 				return err
 			}
 		}
 		return nil
 	})

 	if err != nil {
 		return err
 	}
 	err = touch(dir, name+"-"+version)
 	if err != nil {
 		return err
 	}
 	return nil

 }

 // download a prerequisite
 func downloadPrereq(name string, version string) error {

 	// names and version
 	// xname = executeable name
 	// vname = versioned executable name
 	xname := addExeExt(name)
 	vname := xname + "-" + version

 	// ensure bindir
 	bindir, err := EnsureBindir()
 	if err != nil {
 		return err
 	}

 	// check if file and version exists
 	trace("checking", vname, version)
 	if exists(bindir, vname) {
 		trace("already downloaded", vname)
 		return nil
 	}

 	// checking different versions of the same file
 	oldver, seen := PrereqSeenMap[name]
 	if seen {
 		if oldver == version {
 			trace("same version again", vname)
 			return nil
 		}
 		return fmt.Errorf("WARNING: %s prerequisite found twice with different versions!\nPrevious version: %s, ignoring %s", name, oldver, version)
 	}
 	PrereqSeenMap[name] = version

 	if taskDryRun {
 		fmt.Printf("downloading %s %s\n", name, version)
 		touch(bindir, name)
 	} else {
 		fmt.Printf("ensuring prerequisite %s %s\n", name, version)
 		execPrereqTask(bindir, name)
 		// check if file and version exists

 		if !exists(bindir, xname) {
 			return fmt.Errorf("failed to download %s version %s", name, version)
 		}
 		// check if a file is zero length and remove in this case
 		fileInfo, err := os.Stat(joinpath(bindir, xname))
 		if err != nil {
 			return fmt.Errorf("failed to download %s version %s", name, version)
 		}
 		if fileInfo.Size() == 0 {
 			trace("removing the empty file ", xname)
 			err := os.Remove(joinpath(bindir, xname))
 			if err != nil {
 				return fmt.Errorf("cannot remove empty %s ", xname)
 			}
 		}
 	}
 	return touchAndClean(bindir, xname, version)
 }

 // ensure prereq are satified looking at the prereq.yml
 func ensurePrereq(root string) error {
 	// skip prereq - useful for tests
 	if os.Getenv("OPS_NO_PREREQ") != "" {
 		return nil
 	}
 	err := os.Chdir(root)
 	if err != nil {
 		return err
 	}
 	trace("ensurePrereq in", root)
 	tasks, versions, err := loadPrereq(root)
 	if err != nil {
 		return err
 	}
 	trace(tasks, versions, err)
 	for i, task := range tasks {
 		version := versions[i]
 		trace("prereq", task, version)
 		err = downloadPrereq(task, version)
 		if err != nil {
 			fmt.Printf("error in prereq %s: %v\n", task, err)
 		}
 	}
 	return nil
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you 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 openserverless

	import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	"github.com/apache/openserverless-cli/tools"
	"github.com/mitchellh/go-homedir"
	"gopkg.in/yaml.v3"
	)

	var PrereqSeenMap = map[string]string{}

	// execute prereq task
	func execPrereqTask(bindir string, name string) error {
	me, err := os.Executable()
	if err != nil {
	return err
	}
	args := []string{
	"-task",
	"-d", bindir,
	"-t", PREREQ,
	name,
	}
	if taskDryRun {
	fmt.Printf("invoking prereq for %s\n", name)
	return nil
	}
	trace("Exec:", me, args)
	err = exec.Command(me, args...).Run()
	if err != nil {
	return err
	}
	return nil
	}

	// load prerequisites in current dir
	func loadPrereq(dir string) (tasks []string, versions []string, err error) {
	err = nil
	tasks = []string{}
	versions = []string{}

	if !exists(dir, PREREQ) {
	return
	}
	trace("found prereq.yml in ", dir)

	data, err := os.ReadFile(joinpath(dir, PREREQ))
	if err != nil {
	return
	}

	/*
	You have tasks = []strings and versions = []strings
	and dat a string with a YAML in format:
	```yaml
	something:
	tasks:
	task:
	vars:
	VERSION: "123"
	anothertask:
	```
	I want to parse the file, find the entries under `tasks` vith a var with VERSION
	and append, in order, to tasks the name of the task
	and to version the version found
	I have to skip the entries without a version and everyhing not in tasks
	I wnato just the plain code no procedures
	*/
	var root yaml.Node
	if err = yaml.Unmarshal([]byte(data), &root); err != nil {
	return
	}

	for i := 0; i < len(root.Content[0].Content); i += 2 {
	if root.Content[0].Content[i].Value == "tasks" {
	tasksNode := root.Content[0].Content[i+1]
	for j := 0; j < len(tasksNode.Content); j += 2 {
	taskName := tasksNode.Content[j].Value
	taskVars := tasksNode.Content[j+1]
	for k := 0; k < len(taskVars.Content); k += 2 {
	if taskVars.Content[k].Value == "vars" {
	varsNode := taskVars.Content[k+1]
	for l := 0; l < len(varsNode.Content); l += 2 {
	if varsNode.Content[l].Value == "VERSION" {
	version := varsNode.Content[l+1].Value
	tasks = append(tasks, taskName)
	versions = append(versions, version)
	}
	}
	}
	}
	}
	}
	}
	return
	}

	func binDir() (string, error) {
	var err error
	bindir := os.Getenv("OPS_BIN")
	if bindir == "" {
	bindir, err = homedir.Expand(fmt.Sprintf("~/.ops/%s-%s/bin", tools.GetOS(), tools.GetARCH()))
	if err != nil {
	return "", err
	}
	}
	os.Setenv("OPS_BIN", bindir)
	return bindir, nil
	}

	func addExeExt(name string) string {
	if tools.GetOS() == "windows" {
	return name + ".exe"
	}
	return name
	}

	// ensure there is a bindir for downloading prerequisites
	// read it from OPS_BIN and create it
	// otherwise setup one in ~/ops/<os>-<arch>/bin
	// and sets OPS_BIN
	func EnsureBindir() (string, error) {
	var err error = nil
	bindir, err := binDir()
	if err != nil {
	return "", err
	}
	err = os.MkdirAll(bindir, 0755)
	if err != nil {
	return "", err
	}
	trace("bindir", bindir)
	return bindir, nil
	}

	// create a mark of current version touching <name>-<version> and remove all the other files starting with <name>-
	func touchAndClean(dir string, name string, version string) error {

	// Walk through the directory
	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
	if err != nil {
	return err
	}

	// Check if the file starts with the prefix
	if !info.IsDir() && strings.HasPrefix(info.Name(), name+"-") {
	trace("Removing file:", path)
	err := os.Remove(path)
	if err != nil {
	return err
	}
	}
	return nil
	})

	if err != nil {
	return err
	}
	err = touch(dir, name+"-"+version)
	if err != nil {
	return err
	}
	return nil

	}

	// download a prerequisite
	func downloadPrereq(name string, version string) error {

	// names and version
	// xname = executeable name
	// vname = versioned executable name
	xname := addExeExt(name)
	vname := xname + "-" + version

	// ensure bindir
	bindir, err := EnsureBindir()
	if err != nil {
	return err
	}

	// check if file and version exists
	trace("checking", vname, version)
	if exists(bindir, vname) {
	trace("already downloaded", vname)
	return nil
	}

	// checking different versions of the same file
	oldver, seen := PrereqSeenMap[name]
	if seen {
	if oldver == version {
	trace("same version again", vname)
	return nil
	}
	return fmt.Errorf("WARNING: %s prerequisite found twice with different versions!\nPrevious version: %s, ignoring %s", name, oldver, version)
	}
	PrereqSeenMap[name] = version

	if taskDryRun {
	fmt.Printf("downloading %s %s\n", name, version)
	touch(bindir, name)
	} else {
	fmt.Printf("ensuring prerequisite %s %s\n", name, version)
	execPrereqTask(bindir, name)
	// check if file and version exists

	if !exists(bindir, xname) {
	return fmt.Errorf("failed to download %s version %s", name, version)
	}
	// check if a file is zero length and remove in this case
	fileInfo, err := os.Stat(joinpath(bindir, xname))
	if err != nil {
	return fmt.Errorf("failed to download %s version %s", name, version)
	}
	if fileInfo.Size() == 0 {
	trace("removing the empty file ", xname)
	err := os.Remove(joinpath(bindir, xname))
	if err != nil {
	return fmt.Errorf("cannot remove empty %s ", xname)
	}
	}
	}
	return touchAndClean(bindir, xname, version)
	}

	// ensure prereq are satified looking at the prereq.yml
	func ensurePrereq(root string) error {
	// skip prereq - useful for tests
	if os.Getenv("OPS_NO_PREREQ") != "" {
	return nil
	}
	err := os.Chdir(root)
	if err != nil {
	return err
	}
	trace("ensurePrereq in", root)
	tasks, versions, err := loadPrereq(root)
	if err != nil {
	return err
	}
	trace(tasks, versions, err)
	for i, task := range tasks {
	version := versions[i]
	trace("prereq", task, version)
	err = downloadPrereq(task, version)
	if err != nil {
	fmt.Printf("error in prereq %s: %v\n", task, err)
	}
	}
	return nil
	}