Fixed issue with iterating over rules

go.mod

@@ -3,25 +3,20 @@ module github.com/mensaah/reka
 go 1.14
 
 require (
-	github.com/aws/aws-sdk-go-v2 v0.28.0
-	github.com/aws/aws-sdk-go-v2/config v0.2.1
-	github.com/aws/aws-sdk-go-v2/credentials v0.1.3
-	github.com/aws/aws-sdk-go-v2/feature/s3/manager v0.1.1
-	github.com/aws/aws-sdk-go-v2/service/ec2 v0.28.0
-	github.com/aws/aws-sdk-go-v2/service/s3 v0.28.0
-	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/aws/aws-sdk-go-v2 v0.29.0
+	github.com/aws/aws-sdk-go-v2/config v0.2.2
+	github.com/aws/aws-sdk-go-v2/credentials v0.1.4
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v0.1.2
+	github.com/aws/aws-sdk-go-v2/service/ec2 v0.29.0
+	github.com/aws/aws-sdk-go-v2/service/s3 v0.29.0
 	github.com/gin-gonic/gin v1.6.3
-	github.com/go-co-op/gocron v0.3.1
-	github.com/go-sql-driver/mysql v1.5.0 // indirect
+	github.com/go-co-op/gocron v0.3.2
 	github.com/jinzhu/now v1.1.1
 	github.com/labstack/gommon v0.3.0
-	github.com/pelletier/go-toml v1.8.1 // indirect
-	github.com/sirupsen/logrus v1.4.2
-	github.com/spf13/pflag v1.0.3
-	github.com/spf13/viper v1.7.0
-	golang.org/x/sys v0.0.0-20200918174421-af09f7315aff // indirect
-	gopkg.in/yaml.v2 v2.3.0 // indirect
-	gorm.io/driver/postgres v1.0.0
-	gorm.io/driver/sqlite v1.1.2
-	gorm.io/gorm v1.20.0
+	github.com/sirupsen/logrus v1.7.0
+	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.7.1
+	gorm.io/driver/postgres v1.0.5
+	gorm.io/driver/sqlite v1.1.3
+	gorm.io/gorm v1.20.5
 )

provider/aws/ec2.go

@@ -20,7 +20,7 @@ func getInstanceDetails(svc *ec2.Client, output *ec2.DescribeInstancesOutput, re
 	for _, reservation := range output.Reservations {
 		for _, instance := range reservation.Instances {
 			// https://stackoverflow.com/a/48554123/7167357
-			tags := utils.ParseTags(*(*[]utils.AWSTag)(unsafe.Pointer(&instance.Tags)))
+			tags := utils.ParseTags(*(*[]*utils.AWSTag)(unsafe.Pointer(&instance.Tags)))
 
 			// We need the creation-date when parsing Tags for relative defintions
 			// EC2 Instances Launch Time is not the creation date. It's the time it was last launched.

provider/aws/s3.go

@@ -43,7 +43,7 @@ func getS3BucketTags(svc *s3.Client, bucketName string, logger *log.Entry) (reso
 		return resource.Tags{}, err
 	}
 	// https://stackoverflow.com/a/48554123/7167357
-	tags := utils.ParseTags(*(*[]utils.AWSTag)(unsafe.Pointer(&result.TagSet)))
+	tags := utils.ParseTags(*((*[]*utils.AWSTag)(unsafe.Pointer(&result.TagSet))))
 	return tags, nil
 }
 

provider/aws/utils/tags.go

@@ -11,7 +11,7 @@ type AWSTag struct {
 }
 
 // ParseTags Returns a valid Tags type from AWS Instance Tags
-func ParseTags(tags []AWSTag) resource.Tags {
+func ParseTags(tags []*AWSTag) resource.Tags {
 	t := make(resource.Tags)
 
 	for _, tag := range tags {

provider/provider.go

@@ -13,6 +13,12 @@ import (
 // resources managed by the manager
 type Resources map[string][]*resource.Resource
 
+type SafeResources struct {
+	mu  sync.Mutex
+	v   Resources
+	err map[string]error
+}
+
 // Provider : Provider definition
 // Implements all logic for controlling Resource Managers
 type Provider struct {
@@ -25,67 +31,86 @@ type Provider struct {
 func (p *Provider) GetAllResources() Resources {
 	p.Logger.Info("Fetching All Resources")
 	var wg sync.WaitGroup
-	resources := make(Resources)
+	resources := SafeResources{v: make(Resources)}
 	for _, resMgr := range p.Managers {
 		wg.Add(1)
-		go func(res Resources, resMgr *resource.Manager) {
+		go func(res *SafeResources, resMgr *resource.Manager) {
 			defer wg.Done()
+
 			resMgrResources, err := resMgr.GetAll()
 			if err != nil {
 				resMgr.Logger.Error(err)
 			}
-			res[resMgr.Name] = resMgrResources
-		}(resources, resMgr)
+			res.mu.Lock()
+			defer res.mu.Unlock()
+			res.v[resMgr.Name] = resMgrResources
+		}(&resources, resMgr)
 	}
 	wg.Wait()
-	return resources
+	return resources.v
 }
 
 // GetDestroyableResources : Return the resources which can be destroyed
 func (p *Provider) GetDestroyableResources(resources Resources) Resources {
 	p.Logger.Debug("Getting Destroyable Resources")
+	count := 0
 	destroyableResources := make(Resources)
 	for mgrName, resList := range resources {
 		var destroyableResList []*resource.Resource
 		for _, r := range resList {
-			if rules.GetResourceAction(r) == rules.Destroy {
-				destroyableResList = append(destroyableResList, r)
+			// Returns the first Matching Rule Action for a resource
+			for _, rule := range rules.GetRules() {
+				if action := rule.CheckResource(r); action == rules.Destroy {
+					destroyableResList = append(destroyableResList, r)
+				}
 			}
 		}
+		count += len(destroyableResList)
 		destroyableResources[mgrName] = destroyableResList
 	}
+	p.Logger.Infof("Found %d resources to be destroyed", count)
 	return destroyableResources
 }
 
 // GetStoppableResources : Return the resources which can be stopped
 func (p *Provider) GetStoppableResources(resources Resources) Resources {
 	p.Logger.Debug("Getting Stoppable Resources")
 	stoppableResources := make(Resources)
+	count := 0
 	for mgrName, resList := range resources {
 		var stoppableResList []*resource.Resource
 		for _, r := range resList {
-			if r.IsActive() && rules.GetResourceAction(r) == rules.Stop {
-				stoppableResList = append(stoppableResList, r)
+			for _, rule := range rules.GetRules() {
+				if action := rule.CheckResource(r); r.IsActive() && action == rules.Stop {
+					stoppableResList = append(stoppableResList, r)
+				}
 			}
 		}
+		count += len(stoppableResList)
 		stoppableResources[mgrName] = stoppableResList
 	}
+	p.Logger.Infof("Found %d resources to be stopped", count)
 	return stoppableResources
 }
 
 // GetResumableResources : Return the resources which can be Resumed
 func (p *Provider) GetResumableResources(resources Resources) Resources {
 	p.Logger.Debug("Getting resumable Resources")
 	resumableResource := make(Resources)
+	count := 0
 	for mgrName, resList := range resources {
 		var resumableResList []*resource.Resource
 		for _, r := range resList {
-			if r.IsStopped() && rules.GetResourceAction(r) == rules.Resume {
-				resumableResList = append(resumableResList, r)
+			for _, rule := range rules.GetRules() {
+				if action := rule.CheckResource(r); r.IsStopped() && action == rules.Resume {
+					resumableResList = append(resumableResList, r)
+				}
 			}
 		}
 		resumableResource[mgrName] = resumableResList
 	}
+	count += len(resumableResource)
+	p.Logger.Infof("Found %d resources to be resumed", count)
 	return resumableResource
 }
 
@@ -98,14 +123,20 @@ func (p *Provider) GetUnusedResources(resources Resources) Resources {
 func (p *Provider) DestroyResources(resources Resources) map[string]string {
 	errs := make(map[string]string)
 	p.Logger.Debugf("Destroying Resources...")
+	var wg sync.WaitGroup
 
 	for mgrName, res := range resources {
-		mgr := p.getManager(mgrName)
-		mgr.Logger.Debugf("Destroying %s ", mgrName)
-		if err := mgr.Destroy(res); err != nil {
-			errs[mgrName] = err.Error()
-		}
+		wg.Add(1)
+		go func(mgrName string, res []*resource.Resource) {
+			defer wg.Done()
+			mgr := p.getManager(mgrName)
+			mgr.Logger.Debugf("Destroying %s ", mgrName)
+			if err := mgr.Destroy(res); err != nil {
+				errs[mgrName] = err.Error()
+			}
+		}(mgrName, res)
 	}
+	wg.Wait()
 	return errs
 }
 

rules/rule.go

@@ -114,8 +114,8 @@ func GetRules() []Ruler {
 func GetResourceAction(res *resource.Resource) Action {
 	// Returns the first Matching Rule Action for a resource
 	for _, r := range rules {
-		if r.CheckResource(res) != DoNothing {
-			return r.CheckResource(res)
+		if action := r.CheckResource(res); action != DoNothing {
+			return action
 		}
 	}
 	return DoNothing

web/main.go

@@ -30,6 +30,7 @@ import (
 	"github.com/mensaah/reka/config"
 	"github.com/mensaah/reka/provider"
 	"github.com/mensaah/reka/provider/aws"
+	"github.com/mensaah/reka/resource"
 	"github.com/mensaah/reka/rules"
 	"github.com/mensaah/reka/web/controllers"
 	"github.com/mensaah/reka/web/models"
@@ -53,7 +54,10 @@ func main() {
 	cfg := config.GetConfig()
 
 	for _, rule := range cfg.Rules {
-		rules.ParseRule(*((*rules.Rule)(unsafe.Pointer(&rule))))
+		// Convert Rule in config to rules.Rule type
+		r := *((*rules.Rule)(unsafe.Pointer(&rule)))
+		r.Tags = resource.Tags(rule.Tags)
+		rules.ParseRule(r)
 	}
 
 	// Initialize Provider objects
@@ -138,10 +142,10 @@ func refreshResources(providers []*provider.Provider) {
 			}
 		}
 		destroyableResources := provider.GetDestroyableResources(allResources)
-		fmt.Println(destroyableResources)
-		// stoppableResources := provider.GetStoppableResources(allResources)
-		// save(stoppableResources)
-		// resumableResources := provider.GetResumableResources(allResources)
-		// save(resumableResources)
+		fmt.Println("Destroyable Resources: ", destroyableResources)
+		stoppableResources := provider.GetStoppableResources(allResources)
+		fmt.Println("Stoppable Resources: ", stoppableResources)
+		resumableResources := provider.GetResumableResources(allResources)
+		fmt.Println("Resumable Resources: ", resumableResources)
 	}
 }