[runx] Allow non-archived binaries (#172)

## Summary

Some repos (e.g. https://github.com/mvdan/gofumpt) release files as
binaries instead of archives. This expands runx to treat unknown files
(that still match the platform and architecture name structure) as
binaries. It only does so if it finds a compatible artifact but the type
is unknown.

We could additionally test the mime type of the file, but it doesn't
seem like binaries use consistent mime types.

## How was it tested?

`./dist/runx +mvdan/gofumpt gofumpt --help`

Author: mikeland73

pkg/sandbox/runx/impl/registry/artifact.go

@@ -9,16 +9,21 @@ import (
 )
 
 func findArtifactForPlatform(artifacts []types.ArtifactMetadata, platform types.Platform) *types.ArtifactMetadata {
+	var artifactForPlatform types.ArtifactMetadata
 	for _, artifact := range artifacts {
-		if isArtifactForPlatform(artifact, platform) && isKnownArchive(artifact.Name) {
-			// We only consider known artchives because sometimes releases contain multiple files
-			// for the same platform. Some times those files are alternative installation methods
-			// like `.dmg`, `.msi`, or `.deb`, and sometimes they are metadata files like `.sha256`
-			// or a `.sig` file. We don't want to install those.
-			return &artifact
+		if isArtifactForPlatform(artifact, platform) {
+			artifactForPlatform = artifact
+			if isKnownArchive(artifact.Name) {
+				// We only consider known archives because sometimes releases contain multiple files
+				// for the same platform. Some times those files are alternative installation methods
+				// like `.dmg`, `.msi`, or `.deb`, and sometimes they are metadata files like `.sha256`
+				// or a `.sig` file. We don't want to install those.
+				return &artifact
+			}
 		}
 	}
-	return nil
+	// Best attempt:
+	return &artifactForPlatform
 }
 
 func isArtifactForPlatform(artifact types.ArtifactMetadata, platform types.Platform) bool {

pkg/sandbox/runx/impl/registry/extract.go

@@ -2,8 +2,10 @@ package registry
 
 import (
 	"context"
+	"errors"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/codeclysm/extract"
 	"go.jetpack.io/pkg/sandbox/runx/impl/fileutil"
@@ -53,3 +55,24 @@ func contentDir(path string) string {
 	}
 	return filepath.Join(path, contents[0].Name())
 }
+
+func createSymbolicLink(src, dst, repoName string) error {
+	if err := os.MkdirAll(dst, 0700); err != nil {
+		return err
+	}
+	if err := os.Chmod(src, 0755); err != nil {
+		return err
+	}
+	binaryName := filepath.Base(src)
+	// This is a good guess for the binary name. In the future we could allow
+	// user to customize.
+	if strings.Contains(binaryName, repoName) {
+		binaryName = repoName
+	}
+	err := os.Symlink(src, filepath.Join(dst, binaryName))
+	if errors.Is(err, os.ErrExist) {
+		// TODO: verify symlink points to the right place
+		return nil
+	}
+	return err
+}

pkg/sandbox/runx/impl/registry/registry.go

@@ -1,6 +1,7 @@
 package registry
 
 import (
+	"bytes"
 	"context"
 	"os"
 	"path/filepath"
@@ -118,7 +119,11 @@ func (r *Registry) GetPackage(ctx context.Context, ref types.PkgRef, platform ty
 		return "", err
 	}
 
-	err = Extract(ctx, artifactPath, installPath.String())
+	if isKnownArchive(filepath.Base(artifactPath)) {
+		err = Extract(ctx, artifactPath, installPath.String())
+	} else if isExecutableBinary(artifactPath) {
+		err = createSymbolicLink(artifactPath, installPath.String(), resolvedRef.Repo)
+	}
 	if err != nil {
 		return "", err
 	}
@@ -160,3 +165,37 @@ func (r *Registry) ResolveVersion(ref types.PkgRef) (types.PkgRef, error) {
 		Version: latestVersion,
 	}, nil
 }
+
+// Best effort heuristic to determine if the artifact is an executable binary.
+func isExecutableBinary(path string) bool {
+	file, err := os.Open(path)
+	if err != nil {
+		return false
+	}
+	defer file.Close()
+
+	header := make([]byte, 4)
+	_, err = file.Read(header)
+	if err != nil {
+		return false
+	}
+
+	switch {
+	case bytes.HasPrefix(header, []byte("#!")): // Shebang
+		return true
+	case bytes.HasPrefix(header, []byte{0x7f, 0x45}): // ELF
+		return true
+	case bytes.Equal(header, []byte{0xfe, 0xed, 0xfa, 0xce}): // MachO32 BE
+		return true
+	case bytes.Equal(header, []byte{0xfe, 0xed, 0xfa, 0xcf}): // MachO64 BE
+		return true
+	case bytes.Equal(header, []byte{0xca, 0xfe, 0xba, 0xbe}): // Java class
+		return true
+	case bytes.Equal(header, []byte{0xCF, 0xFA, 0xED, 0xFE}): // Little-endian mac 64-bit
+		return true
+	case bytes.Equal(header, []byte{0xCE, 0xFA, 0xED, 0xFE}): // Little-endian mac 32-bit
+		return true
+	default:
+		return false
+	}
+}

pkg/sandbox/runx/impl/registry/registry_test.go

@@ -0,0 +1,44 @@
+package registry
+
+import (
+	"os"
+	"testing"
+)
+
+func TestIsBinary(t *testing.T) {
+	tests := []struct {
+		name   string
+		header []byte
+		want   bool
+	}{
+		{"Shebang", []byte("#!/bin/bash\n"), true},
+		{"ELF", []byte{0x7f, 0x45, 0x4c, 0x46}, true},
+		{"MachO32 BE", []byte{0xfe, 0xed, 0xfa, 0xce}, true},
+		{"MachO64 BE", []byte{0xfe, 0xed, 0xfa, 0xcf}, true},
+		{"Java Class", []byte{0xca, 0xfe, 0xba, 0xbe}, true},
+		{"MachO64 LE", []byte{0xcf, 0xfa, 0xed, 0xfe}, true},
+		{"MachO32 LE", []byte{0xce, 0xfa, 0xed, 0xfe}, true},
+		{"Unknown", []byte{0xaa, 0xbb, 0xcc, 0xdd}, false},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := os.CreateTemp("", "testfile")
+			if err != nil {
+				t.Fatalf("Could not create temp file: %v", err)
+			}
+			defer os.Remove(file.Name())
+
+			_, err = file.Write(test.header)
+			if err != nil {
+				t.Fatalf("Could not write to temp file: %v", err)
+			}
+			file.Close()
+
+			got := isExecutableBinary(file.Name())
+			if got != test.want {
+				t.Errorf("isBinary() = %v, want %v", got, test.want)
+			}
+		})
+	}
+}