Add scope support

pkg/scope/scope.go

@@ -1,14 +1,23 @@
 package scope
 
 import (
+	"context"
+	"encoding/json"
+	"fmt"
 	"net/http"
 	"regexp"
 	"sync"
+
+	"github.com/dstotijn/hetty/pkg/proj"
 )
 
+const moduleName = "scope"
+
 type Scope struct {
-	mu    sync.RWMutex
 	rules []Rule
+	repo  Repository
+
+	mu sync.RWMutex
 }
 
 type Rule struct {
@@ -22,11 +31,26 @@ type Header struct {
 	Value *regexp.Regexp
 }
 
-func New(rules []Rule) *Scope {
-	s := &Scope{}
-	if rules != nil {
-		s.rules = rules
+func New(repo Repository, projService *proj.Service) *Scope {
+	s := &Scope{
+		repo: repo,
 	}
+
+	projService.OnProjectOpen(func(_ string) error {
+		err := s.load(context.Background())
+		if err == proj.ErrNoSettings {
+			return nil
+		}
+		if err != nil {
+			return fmt.Errorf("scope: could not load scope: %v", err)
+		}
+		return nil
+	})
+	projService.OnProjectClose(func(_ string) error {
+		s.unload()
+		return nil
+	})
+
 	return s
 }
 
@@ -36,11 +60,41 @@ func (s *Scope) Rules() []Rule {
 	return s.rules
 }
 
-func (s *Scope) SetRules(rules []Rule) {
+func (s *Scope) load(ctx context.Context) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
+	var rules []Rule
+	err := s.repo.FindSettingsByModule(ctx, moduleName, &rules)
+	if err == proj.ErrNoSettings {
+		return err
+	}
+	if err != nil {
+		return fmt.Errorf("scope: could not load scope settings: %v", err)
+	}
+
 	s.rules = rules
+
+	return nil
+}
+
+func (s *Scope) unload() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.rules = nil
+}
+
+func (s *Scope) SetRules(ctx context.Context, rules []Rule) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if err := s.repo.UpsertSettings(ctx, moduleName, rules); err != nil {
+		return fmt.Errorf("scope: cannot set rules in repository: %v", err)
+	}
+
+	s.rules = rules
+
+	return nil
 }
 
 func (s *Scope) Match(req *http.Request, body []byte) bool {
@@ -97,3 +151,87 @@ func (r Rule) Match(req *http.Request, body []byte) bool {
 
 	return false
 }
+
+// MarshalJSON implements json.Marshaler.
+func (r Rule) MarshalJSON() ([]byte, error) {
+	type headerDTO struct {
+		Key   string
+		Value string
+	}
+	type ruleDTO struct {
+		URL    string
+		Header headerDTO
+		Body   string
+	}
+
+	dto := ruleDTO{
+		URL: regexpToString(r.URL),
+		Header: headerDTO{
+			Key:   regexpToString(r.Header.Key),
+			Value: regexpToString(r.Header.Value),
+		},
+		Body: regexpToString(r.Body),
+	}
+
+	return json.Marshal(dto)
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (r *Rule) UnmarshalJSON(data []byte) error {
+	type headerDTO struct {
+		Key   string
+		Value string
+	}
+	type ruleDTO struct {
+		URL    string
+		Header headerDTO
+		Body   string
+	}
+
+	var dto ruleDTO
+	if err := json.Unmarshal(data, &dto); err != nil {
+		return err
+	}
+
+	url, err := stringToRegexp(dto.URL)
+	if err != nil {
+		return err
+	}
+	headerKey, err := stringToRegexp(dto.Header.Key)
+	if err != nil {
+		return err
+	}
+	headerValue, err := stringToRegexp(dto.Header.Value)
+	if err != nil {
+		return err
+	}
+	body, err := stringToRegexp(dto.Body)
+	if err != nil {
+		return err
+	}
+
+	*r = Rule{
+		URL: url,
+		Header: Header{
+			Key:   headerKey,
+			Value: headerValue,
+		},
+		Body: body,
+	}
+
+	return nil
+}
+
+func regexpToString(r *regexp.Regexp) string {
+	if r == nil {
+		return ""
+	}
+	return r.String()
+}
+
+func stringToRegexp(s string) (*regexp.Regexp, error) {
+	if s == "" {
+		return nil, nil
+	}
+	return regexp.Compile(s)
+}