290 lines
7.0 KiB
Go
290 lines
7.0 KiB
Go
package dependencies
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"runtime"
|
|
"strings"
|
|
|
|
"git.dev.m-and-m.ovh/mderasse/gouick/models"
|
|
"github.com/blang/semver"
|
|
"github.com/juju/errors"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// minimumGolangVersion is the minimum minor required for the app to work.
|
|
const minimumSwaggerVersion = "0.30.3"
|
|
|
|
// installation directory for fresh install.
|
|
// will be prefixed by $HOME.
|
|
const defaultSwaggerInstallDir = "/bin"
|
|
|
|
var regexSwaggerVersion = regexp.MustCompile(`^version: v(\d+\.\d+\.\d+)`)
|
|
|
|
// Swagger represent an empty struct respecting the DependencyInterface.
|
|
type Swagger struct{}
|
|
|
|
// regroup all swagger dependencies function.
|
|
|
|
// GetName return the name of the dependency using DependencyName enum.
|
|
func (s Swagger) GetName() models.DependencyName {
|
|
return models.DependencyName_GO_SWAGGER
|
|
}
|
|
|
|
// GetMinimumVersion return the minimum version required for that dependency.
|
|
func (s Swagger) GetMinimumVersion() string {
|
|
return minimumSwaggerVersion
|
|
}
|
|
|
|
// IsInstalled check if the dependency is installed on the system.
|
|
func (s Swagger) IsInstalled() (bool, error) {
|
|
_, err := s.GetBinaryPath()
|
|
if err != nil && !errors.Is(err, exec.ErrNotFound) {
|
|
return false, errors.Trace(err)
|
|
} else if err != nil && errors.Is(err, exec.ErrNotFound) {
|
|
return false, nil
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// GetBinaryPath will search for the binary and return the path if found.
|
|
func (s Swagger) GetBinaryPath() (string, error) {
|
|
log.Debug("looking for swagger binary")
|
|
|
|
path, err := exec.LookPath("swagger")
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
log.Debug("found swagger binary in", path)
|
|
|
|
return path, nil
|
|
}
|
|
|
|
// GetVersion will find the current version of the dependency.
|
|
func (s Swagger) GetVersion() (string, error) {
|
|
|
|
isInstalled, err := s.IsInstalled()
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
if !isInstalled {
|
|
return "", errors.NotFoundf("swagger is not installed on the system")
|
|
}
|
|
|
|
binaryPath, err := s.GetBinaryPath()
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
log.Debug("executing swagger version command")
|
|
|
|
//nolint:gosec // we trust the binary we are launching
|
|
cmd := exec.Command(binaryPath, "version")
|
|
stdout, err := cmd.Output()
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
cleanOut := strings.TrimSpace(string(stdout))
|
|
|
|
log.Debugf("swagger version returned %s", cleanOut)
|
|
|
|
parseOutput := regexSwaggerVersion.FindStringSubmatch(cleanOut)
|
|
if len(parseOutput) != 2 {
|
|
return "", errors.NotSupportedf("failed to parse swagger version output: %s", cleanOut)
|
|
}
|
|
|
|
return parseOutput[1], nil
|
|
}
|
|
|
|
// IsVersionSupported will compare the current version with the minimum expected version.
|
|
func (s Swagger) IsVersionSupported() (bool, error) {
|
|
isInstalled, err := s.IsInstalled()
|
|
if err != nil {
|
|
return false, errors.Trace(err)
|
|
}
|
|
if !isInstalled {
|
|
return false, nil
|
|
}
|
|
|
|
version, err := s.GetVersion()
|
|
if err != nil {
|
|
return false, errors.Trace(err)
|
|
}
|
|
|
|
installedVersion, err := semver.Make(version)
|
|
if err != nil {
|
|
return false, errors.Trace(err)
|
|
}
|
|
|
|
requiredVersion, _ := semver.Make(minimumSwaggerVersion)
|
|
if err != nil {
|
|
return false, errors.Trace(err)
|
|
}
|
|
|
|
if installedVersion.LT(requiredVersion) {
|
|
return false, nil
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// CanBeInstalled define if the dependency installation is handled by the app.
|
|
func (s Swagger) CanBeInstalled() bool {
|
|
return true
|
|
}
|
|
|
|
// DescribeInstall will list the aciton that will be executed for the dependency update or installation.
|
|
func (s Swagger) DescribeInstall(path string) string {
|
|
commands := []string{
|
|
"The following commands will be executed",
|
|
fmt.Sprintf("rm -rf %s/swagger ", path),
|
|
fmt.Sprintf("wget %s -O %s/swagger", s.getDownloadURL(), path),
|
|
fmt.Sprintf("chmod 644 %s/swagger", path),
|
|
}
|
|
|
|
return strings.Join(commands, "\n")
|
|
}
|
|
|
|
// Install will install or update the dependency.
|
|
func (s Swagger) Install(path string) error {
|
|
downloadURL := s.getDownloadURL()
|
|
content, err := downloadFile(downloadURL)
|
|
if err != nil {
|
|
log.Warnf("fail to download file from %s", downloadURL)
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
//nolint:gosec // we did compute the file path
|
|
fh, err := os.OpenFile(
|
|
filepath.Join(path, "swagger"),
|
|
os.O_RDWR|os.O_CREATE|os.O_TRUNC,
|
|
0600,
|
|
)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := fh.Close(); err != nil {
|
|
log.Errorf("Error closing file: %s", err)
|
|
}
|
|
}()
|
|
|
|
bContent, err := io.ReadAll(content)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
_, err = fh.Write(bContent)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DescribePostInstall will list the post installation action that will be executed.
|
|
func (s Swagger) DescribePostInstall(path string) string {
|
|
return `For your environment to work correctly, we will add if needed the following environment variable to your .bashrc:
|
|
|
|
PATH="$HOME/bin:$PATH"
|
|
|
|
You will have to reopen a new terminal to apply the changes or execute the following command:
|
|
|
|
source $HOME/.bashrc
|
|
|
|
`
|
|
}
|
|
|
|
// PostInstall will execute the post installation or update of the dependency.
|
|
func (s Swagger) PostInstall(path string) error {
|
|
lineBashRc := []string{
|
|
"# Swagger - Added by gouick",
|
|
}
|
|
|
|
// checking if swagger binary is found after installation
|
|
// if not it's probably not in the path
|
|
isInstalled, err := s.IsInstalled()
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
if !isInstalled {
|
|
lineBashRc = append(lineBashRc, "PATH=\"$HOME/bin:$PATH\"")
|
|
}
|
|
|
|
homeDir, err := os.UserHomeDir()
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
if len(lineBashRc) > 1 {
|
|
log.Debug("Adding env variable to .bashrc")
|
|
|
|
//nolint:gosec // we did compute the file path
|
|
fh, err := os.OpenFile(
|
|
filepath.Join(homeDir, ".bashrc"),
|
|
os.O_APPEND|os.O_CREATE|os.O_WRONLY,
|
|
0600,
|
|
)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := fh.Close(); err != nil {
|
|
log.Errorf("Error closing file: %s", err)
|
|
}
|
|
}()
|
|
|
|
_, err = fh.WriteString(
|
|
fmt.Sprintf("\n\n%s\n", strings.Join(lineBashRc, "\n")),
|
|
)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetInstallDirectory will try to find the current swagger directory. If it doesn't exist or if it's in a
|
|
// not userspace directory, it will provide the "default"
|
|
// It doesn't mean that the directory is "writable".
|
|
func (s Swagger) GetInstallDirectory() (string, error) {
|
|
homeDir, err := os.UserHomeDir()
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
isInstalled, err := s.IsInstalled()
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
// concat default install dir with home and we have our path
|
|
if !isInstalled {
|
|
return filepath.Join(homeDir, defaultSwaggerInstallDir), nil
|
|
}
|
|
|
|
// now let's play and find the current install path
|
|
binaryPath, err := s.GetBinaryPath()
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
return strings.TrimSuffix(binaryPath, "/swagger"), nil
|
|
}
|
|
|
|
func (s Swagger) getDownloadURL() string {
|
|
return fmt.Sprintf("https://github.com/go-swagger/go-swagger/releases/download/v%s/swagger_%s_%s", minimumSwaggerVersion, runtime.GOOS, runtime.GOARCH)
|
|
}
|