Implemented redis persistence

Author: abhisek

Tasks.todo

@@ -4,6 +4,8 @@ Container Image Scanner API:
   ✔ Define data structure for API request / response @done(20-01-29 15:45)
   ✔ Added CORS @done(20-01-29 11:58)
   ✔ Implement async scanning with in-memory data structure @done(20-01-29 15:45)
-  ☐ Implement async scanning with persistence (Database/Redis)
+  ✔ Implement async scanning with persistence (Redis) @done(20-02-01 12:03)
   ✔ Integrate dockle for CIS benchmark on docker images @done(20-01-31 15:33)
-  ☐ Serve Swagger docs (HTML) from /
+  ☐ Serve Swagger docs (HTML) from /
+  ☐ Test cases
+  ☐ Setup CI in Github

persistence.go

@@ -10,13 +10,13 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-type RedisPersistence struct {
+type Persistence struct {
 	redis *redis.Client
 }
 
 var DEFAULT_EXPIRATION time.Duration = 15 * time.Minute
 
-func (client *RedisPersistence) Init() {
+func (client *Persistence) Init() {
 	log.Debugf("Initializing Redis client")
 
 	client.redis = redis.NewClient(&redis.Options{
@@ -32,7 +32,7 @@ func (client *RedisPersistence) Init() {
 	log.Debugf("Redis client initialized: %s", pong)
 }
 
-func (client *RedisPersistence) SetScanStatus(scanID, status string) error {
+func (client *Persistence) SetScanStatus(scanID, status string) error {
 	key := fmt.Sprintf("scans:%s:status", scanID)
 	_, err := client.redis.Set(key, status, 0).Result()
 
@@ -43,7 +43,7 @@ func (client *RedisPersistence) SetScanStatus(scanID, status string) error {
 	return err
 }
 
-func (client *RedisPersistence) SetScanReport(scanID string, report ScanReport) error {
+func (client *Persistence) SetScanReport(scanID string, report ScanReport) error {
 	key := fmt.Sprintf("scans:%s:report", scanID)
 	data, err := json.Marshal(report)
 
@@ -61,10 +61,32 @@ func (client *RedisPersistence) SetScanReport(scanID string, report ScanReport)
 	return err
 }
 
-func (client *RedisPersistence) GetScanStatus(scanID string) string {
-	return SCAN_STATUS_ERROR
+func (client *Persistence) GetScanStatus(scanID string) string {
+	key := fmt.Sprintf("scans:%s:status", scanID)
+	value, err := client.redis.Get(key).Result()
+
+	if err != nil {
+		log.Debugf("Failed to get status from Redis: %#v", err)
+		return SCAN_STATUS_ERROR
+	}
+
+	return value
 }
 
-func (client *RedisPersistence) GetScanReport(scanID string) (report ScanReport, err error) {
+func (client *Persistence) GetScanReport(scanID string) (report ScanReport, err error) {
+	key := fmt.Sprintf("scans:%s:report", scanID)
+
+	value, err := client.redis.Get(key).Result()
+
+	if err != nil {
+		log.Debugf("Failed to get report from Redis: %#v", err)
+		return report, err
+	}
+
+	err = json.Unmarshal([]byte(value), &report)
+	if err != nil {
+		log.Debugf("Failed to unmarshal report JSON from redis: %#v", err)
+	}
+
 	return report, err
 }

service.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
-	"errors"
 
 	"github.com/google/uuid"
 
@@ -31,10 +30,8 @@ type ScanReport struct {
 
 // Hash index is not addressable in Go so we use flat key-value pairing
 type ScanningService struct {
-	statusMap       map[string]string
-	reportMap       map[string]ScanReport
-	persistentStore RedisPersistence
-	scannerChannel  chan ScanJob
+	store          Persistence
+	scannerChannel chan ScanJob
 }
 
 type ScanJob struct {
@@ -87,11 +84,8 @@ func dockerPullImage(imageRef, user, password string) error {
 func (ctx *ScanningService) Init() {
 	log.Debugf("Initalizing Scanning Service")
 
-	ctx.persistentStore.Init()
-
+	ctx.store.Init()
 	ctx.scannerChannel = make(chan ScanJob, 5)
-	ctx.statusMap = make(map[string]string, 0)
-	ctx.reportMap = make(map[string]ScanReport, 0)
 
 	go func() {
 		for job := range ctx.scannerChannel {
@@ -105,16 +99,16 @@ func (ctx *ScanningService) Init() {
 func (ctx *ScanningService) processJob(job ScanJob) {
 	log.Debugf("Processing scan job with id: %s", job.JobID)
 
-	ctx.statusMap[job.JobID] = SCAN_STATUS_IN_PROGRESS
+	ctx.store.SetScanStatus(job.JobID, SCAN_STATUS_IN_PROGRESS)
 	if report, err := ctx.ScanImage(job.ScanRequest); err != nil {
-		ctx.statusMap[job.JobID] = SCAN_STATUS_ERROR
+		ctx.store.SetScanStatus(job.JobID, SCAN_STATUS_ERROR)
 	} else {
-		ctx.reportMap[job.JobID] = report
-		ctx.statusMap[job.JobID] = SCAN_STATUS_COMPLETED
+		ctx.store.SetScanReport(job.JobID, report)
+		ctx.store.SetScanStatus(job.JobID, SCAN_STATUS_COMPLETED)
 	}
 
 	log.Debugf("Finished processing job with id: %s status: %s",
-		job.JobID, ctx.statusMap[job.JobID])
+		job.JobID, ctx.store.GetScanStatus(job.JobID))
 }
 
 // This method is synchronous
@@ -155,28 +149,16 @@ func (ctx *ScanningService) AsyncScanImage(req ScanRequest) string {
 
 	log.Debugf("Async submit scan for image: %s id: %s", req.ImageRef, scanID)
 
-	ctx.statusMap[job.JobID] = SCAN_STATUS_NEW
+	ctx.store.SetScanStatus(job.JobID, SCAN_STATUS_NEW)
 	ctx.scannerChannel <- job
 
 	return scanID
 }
 
 func (ctx *ScanningService) GetScanStatus(scanID string) string {
-	status, found := ctx.statusMap[scanID]
-
-	if found {
-		return status
-	}
-
-	return SCAN_STATUS_ERROR
+	return ctx.store.GetScanStatus(scanID)
 }
 
 func (ctx *ScanningService) GetScanReport(scanID string) (ScanReport, error) {
-	report, found := ctx.reportMap[scanID]
-
-	if !found {
-		return ScanReport{}, errors.New("Invalid scanID")
-	}
-
-	return report, nil
+	return ctx.store.GetScanReport(scanID)
 }