fix: missed a few renames (raid -> plugin) (#52)

Signed-off-by: jmeridth <[email protected]>

Author: jmeridth

README.md

@@ -76,8 +76,8 @@ loglevel: Debug
 write-directory: sample_output
 services:
   my-cloud-service1:
-    raid: example
-    tactics:
+    plugin: example
+    test-suite:
       - tlp_red
       # - tlp_amber
       # - tlp_green

cmd/list.go

@@ -20,14 +20,14 @@ var listCmd = &cobra.Command{
 	Short: "Consult the Charts! List all plugins that have been installed.",
 	Run: func(cmd *cobra.Command, args []string) {
 		if viper.GetBool("all") {
-			fmt.Fprintln(writer, "| Raid \t | Available \t| Requested \t|")
-			for _, pluginPkg := range GetRaids() {
+			fmt.Fprintln(writer, "| Plugin \t | Available \t| Requested \t|")
+			for _, pluginPkg := range GetPlugins() {
 				fmt.Fprintf(writer, "| %s \t | %t \t| %t \t|\n", pluginPkg.Name, pluginPkg.Available, pluginPkg.Requested)
 			}
 		} else {
 			// list only the available plugins
-			fmt.Fprintln(writer, "| Raid \t | Requested \t|")
-			for _, pluginPkg := range GetRaids() {
+			fmt.Fprintln(writer, "| Plugin \t | Requested \t|")
+			for _, pluginPkg := range GetPlugins() {
 				if pluginPkg.Available {
 					fmt.Fprintf(writer, "| %s \t | %t \t|\n", pluginPkg.Name, pluginPkg.Requested)
 				}
@@ -44,56 +44,56 @@ func init() {
 	viper.BindPFlag("all", listCmd.PersistentFlags().Lookup("all"))
 }
 
-// GetRequestedRaids returns a list of plugin names requested in the config
-func getRequestedRaids() (requestedRaidPackages []*RaidPkg) {
+// GetRequestedPlugins returns a list of plugin names requested in the config
+func getRequestedPlugins() (requestedPluginPackages []*PluginPkg) {
 	services := viper.GetStringMap("services")
 	for serviceName := range services {
 		pluginName := viper.GetString("services." + serviceName + ".plugin")
-		if pluginName != "" && !Contains(requestedRaidPackages, pluginName) {
-			pluginPkg := NewRaidPkg(pluginName, serviceName)
+		if pluginName != "" && !Contains(requestedPluginPackages, pluginName) {
+			pluginPkg := NewPluginPkg(pluginName, serviceName)
 			pluginPkg.Requested = true
-			requestedRaidPackages = append(requestedRaidPackages, pluginPkg)
+			requestedPluginPackages = append(requestedPluginPackages, pluginPkg)
 		}
 	}
-	return requestedRaidPackages
+	return requestedPluginPackages
 }
 
-// GetAvailableRaids returns a list of plugins found in the binaries path
-func getAvailableRaids() (availableRaidPackages []*RaidPkg) {
+// GetAvailablePlugins returns a list of plugins found in the binaries path
+func getAvailablePlugins() (availablePluginPackages []*PluginPkg) {
 	pluginPaths, _ := hcplugin.Discover("*", viper.GetString("binaries-path"))
 	for _, pluginPath := range pluginPaths {
-		pluginPkg := NewRaidPkg(path.Base(pluginPath), "")
+		pluginPkg := NewPluginPkg(path.Base(pluginPath), "")
 		pluginPkg.Available = true
-		if strings.Contains(pluginPkg.Name,  "privateer"){
+		if strings.Contains(pluginPkg.Name, "privateer") {
 			continue
 		}
-		availableRaidPackages = append(availableRaidPackages, pluginPkg)
+		availablePluginPackages = append(availablePluginPackages, pluginPkg)
 	}
-	return availableRaidPackages
+	return availablePluginPackages
 }
 
-var allRaids []*RaidPkg
+var allPlugins []*PluginPkg
 
-func GetRaids() []*RaidPkg {
-	if allRaids != nil {
-		return allRaids
+func GetPlugins() []*PluginPkg {
+	if allPlugins != nil {
+		return allPlugins
 	}
-	output := make([]*RaidPkg, 0)
-	for _, plugin := range getRequestedRaids() {
-		if Contains(getAvailableRaids(), plugin.Name) {
+	output := make([]*PluginPkg, 0)
+	for _, plugin := range getRequestedPlugins() {
+		if Contains(getAvailablePlugins(), plugin.Name) {
 			plugin.Available = true
 		}
 		output = append(output, plugin)
 	}
-	for _, plugin := range getAvailableRaids() {
+	for _, plugin := range getAvailablePlugins() {
 		if !Contains(output, plugin.Name) {
 			output = append(output, plugin)
 		}
 	}
 	return output
 }
 
-func Contains(slice []*RaidPkg, search string) bool {
+func Contains(slice []*PluginPkg, search string) bool {
 	for _, plugin := range slice {
 		if plugin.Name == search {
 			return true

cmd/objects.go

@@ -11,23 +11,23 @@ import (
 	"github.com/spf13/viper"
 )
 
-// RaidError retains an error object and the name of the pack that generated it
-type RaidError struct {
-	Raid string
-	Err  error
+// PluginError retains an error object and the name of the pack that generated it
+type PluginError struct {
+	Plugin string
+	Err    error
 }
 
-// RaidErrors holds a list of errors and an Error() method
+// PluginErrors holds a list of errors and an Error() method
 // so it adheres to the standard Error interface
-type RaidErrors struct {
-	Errors []RaidError
+type PluginErrors struct {
+	Errors []PluginError
 }
 
-func (e *RaidErrors) Error() string {
+func (e *PluginErrors) Error() string {
 	return fmt.Sprintf("Service Pack Errors: %v", e.Errors)
 }
 
-type RaidPkg struct {
+type PluginPkg struct {
 	Name          string
 	Path          string
 	ServiceTarget string
@@ -40,7 +40,7 @@ type RaidPkg struct {
 	Error      error
 }
 
-func (p *RaidPkg) getBinary() (binaryName string, err error) {
+func (p *PluginPkg) getBinary() (binaryName string, err error) {
 	p.Name = filepath.Base(strings.ToLower(p.Name)) // in some cases a filepath may arrive here instead of the base name; overwrite if so
 	if runtime.GOOS == "windows" && !strings.HasSuffix(p.Name, ".exe") {
 		p.Name = fmt.Sprintf("%s.exe", p.Name)
@@ -55,7 +55,7 @@ func (p *RaidPkg) getBinary() (binaryName string, err error) {
 	return
 }
 
-func (p *RaidPkg) queueCmd() {
+func (p *PluginPkg) queueCmd() {
 	cmd := exec.Command(p.Path)
 	flags := []string{
 		fmt.Sprintf("--config=%s", viper.GetString("config")),
@@ -68,8 +68,8 @@ func (p *RaidPkg) queueCmd() {
 	}
 }
 
-func NewRaidPkg(pluginName string, serviceName string) *RaidPkg {
-	plugin := &RaidPkg{
+func NewPluginPkg(pluginName string, serviceName string) *PluginPkg {
+	plugin := &PluginPkg{
 		Name: pluginName,
 	}
 	path, err := plugin.getBinary()

cmd/run.go

@@ -43,17 +43,17 @@ func Run() (err error) {
 	logger.Trace(fmt.Sprintf(
 		"Using bin: %s", viper.GetString("binaries-path")))
 
-	plugins := GetRaids()
+	plugins := GetPlugins()
 	if len(plugins) == 0 {
 		logger.Error("no requested plugins were found in " + viper.GetString("binaries-path"))
 		return
 	}
 
 	// Run all plugins
 	for serviceName := range viper.GetStringMap("services") {
-		serviceRaidName := viper.GetString(fmt.Sprintf("services.%s.plugin", serviceName))
+		servicePluginName := viper.GetString(fmt.Sprintf("services.%s.plugin", serviceName))
 		for _, pluginPkg := range plugins {
-			if pluginPkg.Name == serviceRaidName {
+			if pluginPkg.Name == servicePluginName {
 				if !pluginPkg.Available {
 					logger.Error("Requested plugin that is not installed: " + pluginPkg.Name)
 					continue
@@ -68,16 +68,16 @@ func Run() (err error) {
 					return err
 				}
 				// Request the plugin
-				var rawRaid interface{}
-				rawRaid, err = rpcClient.Dispense(shared.PluginName)
+				var rawPlugin interface{}
+				rawPlugin, err = rpcClient.Dispense(shared.PluginName)
 				if err != nil {
 					logger.Error(err.Error())
 				}
 				// Execute plugin
-				plugin := rawRaid.(shared.Pluginer)
+				plugin := rawPlugin.(shared.Pluginer)
 
 				// Execute
-				logger.Trace("Starting Raid: " + pluginPkg.Name)
+				logger.Trace("Starting Plugin: " + pluginPkg.Name)
 				response := plugin.Start()
 				if response != nil {
 					pluginPkg.Error = fmt.Errorf("Error running plugin for %s: %v", serviceName, response)
@@ -90,9 +90,9 @@ func Run() (err error) {
 	return
 }
 
-func closeClient(pluginPkg *RaidPkg, client *hcplugin.Client) {
+func closeClient(pluginPkg *PluginPkg, client *hcplugin.Client) {
 	if pluginPkg.Successful {
-		logger.Info(fmt.Sprintf("Raid %s completed successfully", pluginPkg.Name))
+		logger.Info(fmt.Sprintf("Plugin %s completed successfully", pluginPkg.Name))
 	} else if pluginPkg.Error != nil {
 		logger.Error(pluginPkg.Error.Error())
 	} else {