chore: process spawning system with alias detection

Signed-off-by: Leonardo Grasso <me@leonardograsso.com>

cmd/run.go

@@ -43,10 +43,13 @@ func NewRun() *cobra.Command {
 		if err != nil {
 			return err
 		}
+		l := logger.StandardLogger()
+
 		r, err := runner.New(
-			runner.WithLogger(logger.StandardLogger()),
+			runner.WithLogger(l),
 			runner.WithKubeFactory(cmdutil.NewFactory(matchVersionKubeConfigFlags)),
 			runner.WithKubeNamespace(ns),
+			runner.WithExecutable("", "--loglevel", l.GetLevel().String(), "run"),
 		)
 		if err != nil {
 			return err

events/interfaces.go

@@ -17,6 +17,8 @@ type Helper interface {
 	// first called order.
 	Cleanup(f func(), args ...interface{})
 
+	SpawnAs(name string, action string) error
+
 	// ResourceBuilder returns a k8s' resource.Builder.
 	ResourceBuilder() *resource.Builder
 }

pkg/runner/helper.go

@@ -0,0 +1,67 @@
+package runner
+
+import (
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	logger "github.com/sirupsen/logrus"
+	"k8s.io/cli-runtime/pkg/resource"
+)
+
+type helper struct {
+	runner  *Runner
+	log     *logger.Entry
+	builder *resource.Builder
+	cleanup func()
+}
+
+func (h *helper) Log() *logger.Entry {
+	return h.log
+}
+
+func (h *helper) ResourceBuilder() *resource.Builder {
+	// todo(leogr): handle nil case
+	return h.builder
+}
+
+// Cleanup registers a function to be called when the action complete or later.
+// Cleanup functions registered from within the same action will be called in last added,
+// first called order.
+func (h *helper) Cleanup(f func(), args ...interface{}) {
+	oldCleanup := h.cleanup
+	h.cleanup = func() {
+		if oldCleanup != nil {
+			defer oldCleanup()
+		}
+		args = append([]interface{}{"clenaup "}, args...)
+		h.Log().Info(args...)
+		f()
+	}
+}
+
+func (h *helper) SpawnAs(name string, action string) error {
+	h.Log().WithField("arg", action).Infof(`spawn as "%s"`, name)
+	tmpDir, err := ioutil.TempDir(os.TempDir(), "falco-event-generator")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tmpDir)
+
+	name = filepath.Join(tmpDir, name)
+	if err := os.Symlink(h.runner.exePath, name); err != nil {
+		return err
+	}
+
+	cmd := exec.Command(name, append(h.runner.exeArgs, action)...)
+
+	out := h.runner.log.Out
+	cmd.Stdout = out
+	cmd.Stderr = out
+	if err := cmd.Run(); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/runner/runner.go

@@ -1,57 +1,36 @@
 package runner
 
 import (
+	"os"
+	"path/filepath"
+
 	"github.com/falcosecurity/event-generator/events"
 	logger "github.com/sirupsen/logrus"
-	"k8s.io/cli-runtime/pkg/resource"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 )
 
 type Runner struct {
-	log *logger.Logger
-	kf  cmdutil.Factory
-	kn  string
-}
-
-type helper struct {
-	log     *logger.Entry
-	builder *resource.Builder
-	cleanup func()
-}
-
-func (h *helper) Log() *logger.Entry {
-	return h.log
-}
-
-func (h *helper) ResourceBuilder() *resource.Builder {
-	// todo(leogr): handle nil case
-	return h.builder
-}
-
-// Cleanup registers a function to be called when the action complete or later.
-// Cleanup functions registered from within the same action will be called in last added,
-// first called order.
-func (h *helper) Cleanup(f func(), args ...interface{}) {
-	oldCleanup := h.cleanup
-	h.cleanup = func() {
-		if oldCleanup != nil {
-			defer oldCleanup()
-		}
-		args = append([]interface{}{"clenaup "}, args...)
-		h.Log().Info(args...)
-		f()
-	}
+	log     *logger.Logger
+	kf      cmdutil.Factory
+	kn      string
+	exePath string
+	exeArgs []string
+	alias   string
 }
 
 func (r *Runner) trigger(n string, f events.Action) (cleanup func(), err error) {
 	fields := logger.Fields{
 		"action": n,
 	}
+	if r.alias != "" {
+		fields["as"] = r.alias
+	}
 	log := r.log.WithFields(fields)
 	log.Info("trigger")
 
 	h := &helper{
-		log: log,
+		runner: r,
+		log:    log,
 	}
 	if r.kf != nil {
 		h.builder = r.kf.NewBuilder().RequireNamespace()
@@ -89,6 +68,16 @@ func (r *Runner) Run(m map[string]events.Action) error {
 	return nil
 }
 
+func procAlias() string {
+	procPath, _ := os.Executable()
+	procName := filepath.Base(procPath)
+	calledAs := filepath.Base(os.Args[0])
+	if procName != calledAs {
+		return calledAs
+	}
+	return ""
+}
+
 func New(options ...Option) (*Runner, error) {
 	r := &Runner{}
 
@@ -100,6 +89,16 @@ func New(options ...Option) (*Runner, error) {
 		r.log = logger.New()
 	}
 
+	if r.exePath == "" {
+		path, err := os.Executable()
+		if err != nil {
+			return nil, err
+		}
+		r.exePath = path
+	}
+
+	r.alias = procAlias()
+
 	return r, nil
 }
 
@@ -123,3 +122,11 @@ func WithKubeNamespace(namespace string) Option {
 		return nil
 	}
 }
+
+func WithExecutable(path string, args ...string) Option {
+	return func(r *Runner) error {
+		r.exePath = path
+		r.exeArgs = args
+		return nil
+	}
+}