Move to Native Testlets

.gitignore

@@ -11,4 +11,5 @@ docs/_build/
 preso_secret/
 client/repeattest.sh
 *.out
-*.DS_Store*
+*.DS_Store*
+agent/testing/downloaded_testlets/

Makefile

@@ -11,9 +11,12 @@ build:
 	docker build -t mierdin/todd -f Dockerfile .
 
 compile:
-	go install ./cmd/...
 
-install: configureenv
+	# Installing testlets
+	./scripts/gettestlets.sh
+
+	# Installing ToDD
+	go install ./cmd/...
 
 fmt:
 	go fmt github.com/mierdin/todd/...
@@ -27,12 +30,20 @@ update_deps:
 
 update_assets:
 	go get -u github.com/jteeuwen/go-bindata/...
-	go-bindata -o assets/assets_unpack.go -pkg="assets" -prefix="agent" agent/testing/testlets/... agent/facts/collectors/...
+	go-bindata -o assets/assets_unpack.go -pkg="assets" -prefix="agent" agent/testing/bashtestlets/... agent/facts/collectors/...
 
 start: compile
+
+	# This mode is just to get a demo of ToDD running within the VM quickly.
+	# It made sense to re-use the configurations for integration testing, so
+	# that's why "server-int.cfg" and "agent-int.cfg" are being used here.
 	start-containers.sh 3 /etc/todd/server-int.cfg /etc/todd/agent-int.cfg
 
-configureenv:
+install:
+
+	# Set capabilities on testlets
+	./scripts/set-testlet-capabilities.sh
+
 	# Copy configs if etc and /etc/todd aren't linked
 	if ! [ "etc" -ef "/etc/todd" ]; then mkdir -p /etc/todd && cp -f ./etc/{agent,server}.cfg /etc/todd/; fi
 	mkdir -p /opt/todd/{agent,server}/assets/{factcollectors,testlets}

Vagrantfile

@@ -8,13 +8,16 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
   config.vm.box_url = "http://cloud-images.ubuntu.com/vagrant/trusty/current/trusty-server-cloudimg-amd64-vagrant-disk1.box"
   config.vm.synced_folder '.', '/home/vagrant/go/src/github.com/Mierdin/todd', nfs: true
 
+  # This is a temporary measure. Once https://github.com/Mierdin/todd/issues/72 is addressed, we can go back
+  # to a single folder being redirected (namely toddproject). For now, since ToDD is still in "Mierdin",
+  # we need to do it this way.
+  config.vm.synced_folder '../../toddproject/todd-nativetestlet-ping', '/home/vagrant/go/src/github.com/toddproject/todd-nativetestlet-ping', nfs: true
 
   config.vm.provider "virtualbox" do |v|
     v.memory = 2048
     v.cpus = 2
   end
 
-
   config.vm.define "todddev" do |todddev|
 
     todddev.vm.host_name = "todddev"

agent/tasks/executetestrun.go

@@ -12,7 +12,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"os"
 	"os/exec"
 	"sync"
@@ -21,6 +20,7 @@ import (
 	log "github.com/Sirupsen/logrus"
 
 	"github.com/Mierdin/todd/agent/cache"
+	"github.com/Mierdin/todd/agent/testing"
 	"github.com/Mierdin/todd/config"
 )
 
@@ -37,9 +37,19 @@ type ExecuteTestRunTask struct {
 // a testrun will be executed once per target, all in parallel.
 func (ett ExecuteTestRunTask) Run() error {
 
+	// gatheredData represents test data from this agent for all targets.
+	// Key is target name, value is JSON output from testlet for that target
+	// This is reset to a blank map every time ExecuteTestRunTask is called
+	gatheredData := map[string]string{}
+
+	// Use a wait group to ensure that all of the testlets have a chance to finish
+	var wg sync.WaitGroup
+
 	// Waiting three seconds to ensure all the agents have their tasks before we potentially hammer the network
-	// TODO(mierdin): This is a bit of a copout. I would like to do something a little more robust than simply waiting
-	// for a few seconds in the future.
+	//
+	// TODO(mierdin): This is a temporary measure - in the future, testruns will be executed via time schedule,
+	// making not only this sleep, but also the entire task unnecessary. Testruns will simply be installed, and
+	// executed when the time is right. This is, in part tracked by https://github.com/Mierdin/todd/issues/89
 	time.Sleep(3000 * time.Millisecond)
 
 	// Retrieve test from cache by UUID
@@ -50,43 +60,37 @@ func (ett ExecuteTestRunTask) Run() error {
 		return errors.New("Problem retrieving testrun from agent cache")
 	}
 
-	// Generate path to testlet and make sure it exists.
-	testlet_path := fmt.Sprintf("%s/assets/testlets/%s", ett.Config.LocalResources.OptDir, tr.Testlet)
-	if _, err := os.Stat(testlet_path); os.IsNotExist(err) {
-		log.Errorf("Testlet %s does not exist on this agent", tr.Testlet)
-		return errors.New("Error executing testrun - testlet doesn't exist on this agent.")
-	}
-
 	log.Debugf("IMMA FIRIN MAH LAZER (for test %s) ", ett.TestUuid)
 
-	// Use a wait group to ensure that all of the testlets have a chance to finish
-	var wg sync.WaitGroup
+	// Specify size of wait group equal to number of targets
 	wg.Add(len(tr.Targets))
 
-	// gatheredData represents test data from this agent for all targets.
-	// Key is target name, value is JSON output from testlet for that target
-	gatheredData := make(map[string]string)
+	testletPath, err := testing.GetTestletPath(tr.Testlet, ett.Config.LocalResources.OptDir)
+	if err != nil {
+		return err
+	}
 
 	// Execute testlets against all targets asynchronously
 	for i := range tr.Targets {
 
 		thisTarget := tr.Targets[i]
 
 		go func() {
+
 			defer wg.Done()
 
-			log.Debugf("Full testlet command and args: '%s %s %s'", testlet_path, thisTarget, tr.Args)
-			cmd := exec.Command(testlet_path, thisTarget, tr.Args)
+			log.Debugf("Full testlet command and args: '%s %s %s'", testletPath, thisTarget, tr.Args)
+			cmd := exec.Command(testletPath, thisTarget, tr.Args)
 
 			// Stdout buffer
 			cmdOutput := &bytes.Buffer{}
 			// Attach buffer to command
 			cmd.Stdout = cmdOutput
 
-			// Execute collector
+			// Execute testlet
 			cmd.Start()
 
-			done := make(chan error, 1)
+			done := make(chan error)
 			go func() {
 				done <- cmd.Wait()
 			}()
@@ -97,22 +101,21 @@ func (ett ExecuteTestRunTask) Run() error {
 			select {
 			case <-time.After(time.Duration(ett.TimeLimit) * time.Second):
 				if err := cmd.Process.Kill(); err != nil {
-					log.Errorf("Failed to kill %s after timeout: %s", testlet_path, err)
+					log.Errorf("Failed to kill %s after timeout: %s", testletPath, err)
 				} else {
-					log.Debug("Successfully killed ", testlet_path)
+					log.Debug("Successfully killed ", testletPath)
 				}
 			case err := <-done:
 				if err != nil {
-					log.Errorf("Testlet %s completed with error '%s'", testlet_path, err)
+					log.Errorf("Testlet %s completed with error '%s'", testletPath, err)
 					gatheredData[thisTarget] = "error"
 				} else {
-					log.Debugf("Testlet %s completed without error", testlet_path)
+					log.Debugf("Testlet %s completed without error", testletPath)
 				}
 			}
 
 			// Record test data
 			gatheredData[thisTarget] = string(cmdOutput.Bytes())
-
 		}()
 	}
 

agent/tasks/installtestrun.go

@@ -11,15 +11,14 @@ package tasks
 import (
 	"bytes"
 	"errors"
-	"fmt"
-	"os"
 	"os/exec"
 	"strings"
 
 	log "github.com/Sirupsen/logrus"
 
 	"github.com/Mierdin/todd/agent/cache"
 	"github.com/Mierdin/todd/agent/defs"
+	"github.com/Mierdin/todd/agent/testing"
 	"github.com/Mierdin/todd/config"
 )
 
@@ -42,16 +41,15 @@ func (itt InstallTestRunTask) Run() error {
 		return errors.New("Testlet parameter for this testrun is null")
 	}
 
-	// Generate path to testlet and make sure it exists.
-	testlet_path := fmt.Sprintf("%s/assets/testlets/%s", itt.Config.LocalResources.OptDir, itt.Tr.Testlet)
-	if _, err := os.Stat(testlet_path); os.IsNotExist(err) {
-		log.Errorf("Testlet %s does not exist on this agent", itt.Tr.Testlet)
-		return errors.New("Error installing testrun - testlet doesn't exist on this agent.")
+	// Determine if this is a native testlet
+	testletPath, err := testing.GetTestletPath(itt.Tr.Testlet, itt.Config.LocalResources.OptDir)
+	if err != nil {
+		return err
 	}
 
 	// Run the testlet in check mode to verify that everything is okay to run this test
-	log.Debug("Running testlet in check mode: ", testlet_path)
-	cmd := exec.Command(testlet_path, "check")
+	log.Debug("Running testlet in check mode: ", testletPath)
+	cmd := exec.Command(testletPath, "check")
 
 	// Stdout buffer
 	cmdOutput := &bytes.Buffer{}
@@ -62,15 +60,15 @@ func (itt InstallTestRunTask) Run() error {
 
 	// This is probably the best cross-platform way to see if check mode passed.
 	if strings.Contains(string(cmdOutput.Bytes()), "Check mode PASSED") {
-		log.Debugf("Check mode for %s passed", testlet_path)
+		log.Debugf("Check mode for %s passed", testletPath)
 	} else {
 		log.Error("Testlet returned an error during check mode: ", string(cmdOutput.Bytes()))
 		return errors.New("Testlet returned an error during check mode")
 	}
 
 	// Insert testrun into agent cache
 	var ac = cache.NewAgentCache(itt.Config)
-	err := ac.InsertTestRun(itt.Tr)
+	err = ac.InsertTestRun(itt.Tr)
 	if err != nil {
 		log.Error(err)
 		return errors.New("Problem installing test run into agent cache")

agent/testing/testing.go

@@ -0,0 +1,67 @@
+/*
+   ToDD testing package
+
+   Contains infrastructure running testlets as well as maintaining
+   conformance for other native-Go testlet projects
+
+   Copyright 2016 Matt Oswalt. Use or modification of this
+   source code is governed by the license provided here:
+   https://github.com/Mierdin/todd/blob/master/LICENSE
+*/
+
+package testing
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	log "github.com/Sirupsen/logrus"
+)
+
+var (
+
+	// This map provides name redirection so that the native testlets can use names that don't
+	// conflict with existing system tools (i.e. using "toddping" instead of "ping") but users
+	// can still refer to the testlets using simple names.
+	//
+	// In short, users refer to the testlet by <key> and this map will redirect to the
+	// actual binary name <value>
+	nativeTestlets = map[string]string{
+		"ping": "toddping",
+	}
+)
+
+// Testlet defines what a testlet should look like if built in native
+// go and compiled with the agent
+type Testlet interface {
+
+	// Run is the "workflow" function for a testlet. All testing takes place here
+	// (or in a function called within)
+	Run(target string, args []string, timeLimit int) (metrics map[string]string, err error)
+}
+
+// GetTestletPath generates whatever path is needed to reach the given testlet
+// It first determines if the referenced testlet is native or not - if it is native,
+// then only the name needs to be returned (all native testlets must be in the path).
+// If it is a custom testlet, then it will generate the full path to the testlet,
+// ensure it is a valid path, and if so, return that full path back to the caller.
+func GetTestletPath(testletName, optDir string) (string, error) {
+
+	if _, ok := nativeTestlets[testletName]; ok {
+		log.Debugf("%s is a native testlet", testletName)
+		return nativeTestlets[testletName], nil
+	}
+
+	log.Debugf("%s is a custom testlet", testletName)
+
+	// Generate path to testlet and make sure it exists.
+	testletPath := fmt.Sprintf("%s/assets/testlets/%s", optDir, testletName)
+	if _, err := os.Stat(testletPath); err != nil {
+		log.Errorf("Problem accessing testlet %q  on this agent", testletName)
+		return "", errors.New("Error installing testrun - problem accessing testrun on agent")
+	}
+
+	return testletPath, nil
+
+}