Initial QSfera import

Server/vendor/go-micro.dev/v4/runtime/local/build/build.go

@@ -0,0 +1,34 @@
+// Package build builds a micro runtime package
+package build
+
+import (
+	"go-micro.dev/v4/runtime/local/source"
+)
+
+// Builder builds binaries.
+type Builder interface {
+	// Build builds a package
+	Build(*Source) (*Package, error)
+	// Clean deletes the package
+	Clean(*Package) error
+}
+
+// Source is the source of a build.
+type Source struct {
+	// Location of the source
+	Repository *source.Repository
+	// Language is the language of code
+	Language string
+}
+
+// Package is micro service package.
+type Package struct {
+	// Source of the binary
+	Source *Source
+	// Name of the binary
+	Name string
+	// Location of the binary
+	Path string
+	// Type of binary
+	Type string
+}

Server/vendor/go-micro.dev/v4/runtime/local/build/options.go

@@ -0,0 +1,15 @@
+package build
+
+type Options struct {
+	// local path to download source
+	Path string
+}
+
+type Option func(o *Options)
+
+// Local path for repository.
+func Path(p string) Option {
+	return func(o *Options) {
+		o.Path = p
+	}
+}

Server/vendor/go-micro.dev/v4/runtime/local/git/git.go

@@ -0,0 +1,341 @@
+package git
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/config"
+	"github.com/go-git/go-git/v5/plumbing"
+)
+
+type Gitter interface {
+	Clone(repo string) error
+	FetchAll(repo string) error
+	Checkout(repo, branchOrCommit string) error
+	RepoDir(repo string) string
+}
+
+type libGitter struct {
+	folder string
+}
+
+func (g libGitter) Clone(repo string) error {
+	fold := filepath.Join(g.folder, dirifyRepo(repo))
+	exists, err := pathExists(fold)
+	if err != nil {
+		return err
+	}
+	if exists {
+		return nil
+	}
+	_, err = git.PlainClone(fold, false, &git.CloneOptions{
+		URL:      repo,
+		Progress: os.Stdout,
+	})
+	return err
+}
+
+func (g libGitter) FetchAll(repo string) error {
+	repos, err := git.PlainOpen(filepath.Join(g.folder, dirifyRepo(repo)))
+	if err != nil {
+		return err
+	}
+	remotes, err := repos.Remotes()
+	if err != nil {
+		return err
+	}
+
+	err = remotes[0].Fetch(&git.FetchOptions{
+		RefSpecs: []config.RefSpec{"refs/*:refs/*", "HEAD:refs/heads/HEAD"},
+		Progress: os.Stdout,
+		Depth:    1,
+	})
+	if err != nil && err != git.NoErrAlreadyUpToDate {
+		return err
+	}
+	return nil
+}
+
+func (g libGitter) Checkout(repo, branchOrCommit string) error {
+	if branchOrCommit == "latest" {
+		branchOrCommit = "master"
+	}
+	repos, err := git.PlainOpen(filepath.Join(g.folder, dirifyRepo(repo)))
+	if err != nil {
+		return err
+	}
+	worktree, err := repos.Worktree()
+	if err != nil {
+		return err
+	}
+
+	if plumbing.IsHash(branchOrCommit) {
+		return worktree.Checkout(&git.CheckoutOptions{
+			Hash:  plumbing.NewHash(branchOrCommit),
+			Force: true,
+		})
+	}
+
+	return worktree.Checkout(&git.CheckoutOptions{
+		Branch: plumbing.NewBranchReferenceName(branchOrCommit),
+		Force:  true,
+	})
+}
+
+func (g libGitter) RepoDir(repo string) string {
+	return filepath.Join(g.folder, dirifyRepo(repo))
+}
+
+type binaryGitter struct {
+	folder string
+}
+
+func (g binaryGitter) Clone(repo string) error {
+	fold := filepath.Join(g.folder, dirifyRepo(repo), ".git")
+	exists, err := pathExists(fold)
+	if err != nil {
+		return err
+	}
+	if exists {
+		return nil
+	}
+	fold = filepath.Join(g.folder, dirifyRepo(repo))
+	cmd := exec.Command("git", "clone", repo, ".")
+
+	err = os.MkdirAll(fold, 0777)
+	if err != nil {
+		return err
+	}
+	cmd.Dir = fold
+	_, err = cmd.Output()
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (g binaryGitter) FetchAll(repo string) error {
+	cmd := exec.Command("git", "fetch", "--all")
+	cmd.Dir = filepath.Join(g.folder, dirifyRepo(repo))
+	outp, err := cmd.CombinedOutput()
+	if err != nil {
+		return errors.New(string(outp))
+	}
+	return err
+}
+
+func (g binaryGitter) Checkout(repo, branchOrCommit string) error {
+	if branchOrCommit == "latest" {
+		branchOrCommit = "master"
+	}
+	cmd := exec.Command("git", "checkout", "-f", branchOrCommit)
+	cmd.Dir = filepath.Join(g.folder, dirifyRepo(repo))
+	outp, err := cmd.CombinedOutput()
+	if err != nil {
+		return errors.New(string(outp))
+	}
+	return nil
+}
+
+func (g binaryGitter) RepoDir(repo string) string {
+	return filepath.Join(g.folder, dirifyRepo(repo))
+}
+
+func NewGitter(folder string) Gitter {
+	if commandExists("git") {
+		return binaryGitter{folder}
+	}
+	return libGitter{folder}
+}
+
+func commandExists(cmd string) bool {
+	_, err := exec.LookPath(cmd)
+	return err == nil
+}
+
+func dirifyRepo(s string) string {
+	s = strings.ReplaceAll(s, "https://", "")
+	s = strings.ReplaceAll(s, "/", "-")
+	return s
+}
+
+// exists returns whether the given file or directory exists.
+func pathExists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return true, err
+}
+
+// GetRepoRoot determines the repo root from a full path.
+// Returns empty string and no error if not found.
+func GetRepoRoot(fullPath string) (string, error) {
+	// traverse parent directories
+	prev := fullPath
+	for {
+		current := prev
+		exists, err := pathExists(filepath.Join(current, ".git"))
+		if err != nil {
+			return "", err
+		}
+		if exists {
+			return current, nil
+		}
+		prev = filepath.Dir(current)
+		// reached top level, see:
+		// https://play.golang.org/p/rDgVdk3suzb
+		if current == prev {
+			break
+		}
+	}
+	return "", nil
+}
+
+const defaultRepo = "github.com/micro/services"
+
+// Source is not just git related @todo move.
+type Source struct {
+	// absolute path to service folder in local mode
+	FullPath string
+	// path of folder to repo root
+	// be it local or github repo
+	Folder string
+	// github ref
+	Ref string
+	// for cloning purposes
+	// blank for local
+	Repo string
+	// dir to repo root
+	// blank for non local
+	LocalRepoRoot string
+	// is it a local folder intended for a local runtime?
+	Local bool
+}
+
+// Name to be passed to RPC call runtime.Create Update Delete
+// eg: `helloworld/api`, `crufter/myrepo/helloworld/api`, `localfolder`
+func (s *Source) RuntimeName() string {
+	if s.Repo == "github.com/micro/services" || s.Repo == "" {
+		return s.Folder
+	}
+	return fmt.Sprintf("%v/%v", strings.ReplaceAll(s.Repo, "github.com/", ""), s.Folder)
+}
+
+// Source to be passed to RPC call runtime.Create Update Delete
+// eg: `helloworld`, `github.com/crufter/myrepo/helloworld`, `/path/to/localrepo/localfolder`
+func (s *Source) RuntimeSource() string {
+	if s.Local {
+		return s.FullPath
+	}
+	if s.Repo == "github.com/micro/services" || s.Repo == "" {
+		return s.Folder
+	}
+	return fmt.Sprintf("%v/%v", s.Repo, s.Folder)
+}
+
+// ParseSource parses a `micro run/update/kill` source.
+func ParseSource(source string) (*Source, error) {
+	// If github is not present, we got a shorthand for `micro/services`
+	if !strings.Contains(source, "github.com") {
+		source = "github.com/micro/services/" + source
+	}
+	if !strings.Contains(source, "@") {
+		source += "@latest"
+	}
+	ret := &Source{}
+	refs := strings.Split(source, "@")
+	ret.Ref = refs[1]
+	parts := strings.Split(refs[0], "/")
+	ret.Repo = strings.Join(parts[0:3], "/")
+	if len(parts) > 1 {
+		ret.Folder = strings.Join(parts[3:], "/")
+	}
+
+	return ret, nil
+}
+
+// ParseSourceLocal detects and handles local pathes too
+// workdir should be used only from the CLI @todo better interface for this function.
+// PathExistsFunc exists only for testing purposes, to make the function side effect free.
+func ParseSourceLocal(workDir, source string, pathExistsFunc ...func(path string) (bool, error)) (*Source, error) {
+	var pexists func(string) (bool, error)
+	if len(pathExistsFunc) == 0 {
+		pexists = pathExists
+	} else {
+		pexists = pathExistsFunc[0]
+	}
+	var localFullPath string
+	if len(workDir) > 0 {
+		localFullPath = filepath.Join(workDir, source)
+	} else {
+		localFullPath = source
+	}
+	if exists, err := pexists(localFullPath); err == nil && exists {
+		localRepoRoot, err := GetRepoRoot(localFullPath)
+		if err != nil {
+			return nil, err
+		}
+		var folder string
+		// If the local repo root is a top level folder, we are not in a git repo.
+		// In this case, we should take the last folder as folder name.
+		if localRepoRoot == "" {
+			folder = filepath.Base(localFullPath)
+		} else {
+			folder = strings.ReplaceAll(localFullPath, localRepoRoot+string(filepath.Separator), "")
+		}
+
+		return &Source{
+			Local:         true,
+			Folder:        folder,
+			FullPath:      localFullPath,
+			LocalRepoRoot: localRepoRoot,
+			Ref:           "latest", // @todo consider extracting branch from git here
+		}, nil
+	}
+	return ParseSource(source)
+}
+
+// CheckoutSource for the local runtime server
+// folder is the folder to check out the source code to
+// Modifies source path to set it to checked out repo absolute path locally.
+func CheckoutSource(folder string, source *Source) error {
+	// if it's a local folder, do nothing
+	if exists, err := pathExists(source.FullPath); err == nil && exists {
+		return nil
+	}
+	gitter := NewGitter(folder)
+	repo := source.Repo
+	if !strings.Contains(repo, "https://") {
+		repo = "https://" + repo
+	}
+	// Always clone, it's idempotent and only clones if needed
+	err := gitter.Clone(repo)
+	if err != nil {
+		return err
+	}
+	source.FullPath = filepath.Join(gitter.RepoDir(source.Repo), source.Folder)
+	return gitter.Checkout(repo, source.Ref)
+}
+
+// code below is not used yet
+
+var nameExtractRegexp = regexp.MustCompile(`((micro|web)\.Name\(")(.*)("\))`)
+
+func extractServiceName(fileContent []byte) string {
+	hits := nameExtractRegexp.FindAll(fileContent, 1)
+	if len(hits) == 0 {
+		return ""
+	}
+	hit := string(hits[0])
+	return strings.Split(hit, "\"")[1]
+}

Server/vendor/go-micro.dev/v4/runtime/local/process/options.go

@@ -0,0 +1,5 @@
+package process
+
+type Options struct{}
+
+type Option func(o *Options)

Server/vendor/go-micro.dev/v4/runtime/local/process/os/os.go

@@ -0,0 +1,95 @@
+//go:build !windows
+// +build !windows
+
+// Package os runs processes locally
+package os
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+	"syscall"
+
+	"go-micro.dev/v4/runtime/local/process"
+)
+
+func (p *Process) Exec(exe *process.Executable) error {
+	cmd := exec.Command(exe.Package.Path)
+	cmd.Dir = exe.Dir
+	return cmd.Run()
+}
+
+func (p *Process) Fork(exe *process.Executable) (*process.PID, error) {
+	// create command
+	cmd := exec.Command(exe.Package.Path, exe.Args...)
+
+	cmd.Dir = exe.Dir
+	// set env vars
+	cmd.Env = append(cmd.Env, os.Environ()...)
+	cmd.Env = append(cmd.Env, exe.Env...)
+
+	// create process group
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+	in, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, err
+	}
+	out, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+	er, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, err
+	}
+	// start the process
+	if err := cmd.Start(); err != nil {
+		return nil, err
+	}
+
+	return &process.PID{
+		ID:     fmt.Sprintf("%d", cmd.Process.Pid),
+		Input:  in,
+		Output: out,
+		Error:  er,
+	}, nil
+}
+
+func (p *Process) Kill(pid *process.PID) error {
+	id, err := strconv.Atoi(pid.ID)
+	if err != nil {
+		return err
+	}
+	if _, err := os.FindProcess(id); err != nil {
+		return err
+	}
+
+	// now kill it
+	// using -ve PID kills the process group which we created in Fork()
+	return syscall.Kill(-id, syscall.SIGTERM)
+}
+
+func (p *Process) Wait(pid *process.PID) error {
+	id, err := strconv.Atoi(pid.ID)
+	if err != nil {
+		return err
+	}
+
+	pr, err := os.FindProcess(id)
+	if err != nil {
+		return err
+	}
+
+	ps, err := pr.Wait()
+	if err != nil {
+		return err
+	}
+
+	if ps.Success() {
+		return nil
+	}
+
+	return fmt.Errorf(ps.String())
+}

Server/vendor/go-micro.dev/v4/runtime/local/process/os/os_windows.go

@@ -0,0 +1,89 @@
+// Package os runs processes locally
+package os
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+
+	"go-micro.dev/v4/runtime/local/process"
+)
+
+func (p *Process) Exec(exe *process.Executable) error {
+	cmd := exec.Command(exe.Package.Path)
+	return cmd.Run()
+}
+
+func (p *Process) Fork(exe *process.Executable) (*process.PID, error) {
+	// create command
+	cmd := exec.Command(exe.Package.Path, exe.Args...)
+	// set env vars
+	cmd.Env = append(cmd.Env, exe.Env...)
+
+	in, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, err
+	}
+	out, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+	er, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, err
+	}
+
+	// start the process
+	if err := cmd.Start(); err != nil {
+		return nil, err
+	}
+
+	return &process.PID{
+		ID:     fmt.Sprintf("%d", cmd.Process.Pid),
+		Input:  in,
+		Output: out,
+		Error:  er,
+	}, nil
+}
+
+func (p *Process) Kill(pid *process.PID) error {
+	id, err := strconv.Atoi(pid.ID)
+	if err != nil {
+		return err
+	}
+
+	pr, err := os.FindProcess(id)
+	if err != nil {
+		return err
+	}
+
+	// now kill it
+	err = pr.Kill()
+
+	// return the kill error
+	return err
+}
+
+func (p *Process) Wait(pid *process.PID) error {
+	id, err := strconv.Atoi(pid.ID)
+	if err != nil {
+		return err
+	}
+
+	pr, err := os.FindProcess(id)
+	if err != nil {
+		return err
+	}
+
+	ps, err := pr.Wait()
+	if err != nil {
+		return err
+	}
+
+	if ps.Success() {
+		return nil
+	}
+
+	return fmt.Errorf(ps.String())
+}

Server/vendor/go-micro.dev/v4/runtime/local/process/os/process.go

@@ -0,0 +1,12 @@
+// Package os runs processes locally
+package os
+
+import (
+	"go-micro.dev/v4/runtime/local/process"
+)
+
+type Process struct{}
+
+func NewProcess(opts ...process.Option) process.Process {
+	return &Process{}
+}

Server/vendor/go-micro.dev/v4/runtime/local/process/process.go

@@ -0,0 +1,43 @@
+// Package process executes a binary
+package process
+
+import (
+	"io"
+
+	"go-micro.dev/v4/runtime/local/build"
+)
+
+// Process manages a running process.
+type Process interface {
+	// Executes a process to completion
+	Exec(*Executable) error
+	// Creates a new process
+	Fork(*Executable) (*PID, error)
+	// Kills the process
+	Kill(*PID) error
+	// Waits for a process to exit
+	Wait(*PID) error
+}
+
+type Executable struct {
+	// Package containing executable
+	Package *build.Package
+	// Initial working directory
+	Dir string
+	// The env variables
+	Env []string
+	// Args to pass
+	Args []string
+}
+
+// PID is the running process.
+type PID struct {
+	// Stdin
+	Input io.Writer
+	// Stdout
+	Output io.Reader
+	// Stderr
+	Error io.Reader
+	// ID of the process
+	ID string
+}

Server/vendor/go-micro.dev/v4/runtime/local/source/options.go

@@ -0,0 +1,15 @@
+package source
+
+type Options struct {
+	// local path to download source
+	Path string
+}
+
+type Option func(o *Options)
+
+// Local path for repository.
+func Path(p string) Option {
+	return func(o *Options) {
+		o.Path = p
+	}
+}

Server/vendor/go-micro.dev/v4/runtime/local/source/source.go

@@ -0,0 +1,22 @@
+// Package source retrieves source code
+package source
+
+// Source retrieves source code.
+type Source interface {
+	// Fetch repo from a url
+	Fetch(url string) (*Repository, error)
+	// Commit and upload repo
+	Commit(*Repository) error
+	// The sourcerer
+	String() string
+}
+
+// Repository is the source repository.
+type Repository struct {
+	// Name or repo
+	Name string
+	// Local path where repo is stored
+	Path string
+	// URL from which repo was retrieved
+	URL string
+}