feat: Add allowed resource provider memory implementations

pkg/solver/store/memory/store.go

@@ -10,21 +10,23 @@ import (
 )
 
 type SolverStoreMemory struct {
-	jobOfferMap      map[string]*data.JobOfferContainer
-	resourceOfferMap map[string]*data.ResourceOfferContainer
-	dealMap          map[string]*data.DealContainer
-	resultMap        map[string]*data.Result
-	matchDecisionMap map[string]*data.MatchDecision
-	mutex            sync.RWMutex
+	jobOfferMap                map[string]*data.JobOfferContainer
+	resourceOfferMap           map[string]*data.ResourceOfferContainer
+	dealMap                    map[string]*data.DealContainer
+	resultMap                  map[string]*data.Result
+	matchDecisionMap           map[string]*data.MatchDecision
+	allowedResourceProviderMap map[string]string
+	mutex                      sync.RWMutex
 }
 
 func NewSolverStoreMemory() (*SolverStoreMemory, error) {
 	return &SolverStoreMemory{
-		jobOfferMap:      map[string]*data.JobOfferContainer{},
-		resourceOfferMap: map[string]*data.ResourceOfferContainer{},
-		dealMap:          map[string]*data.DealContainer{},
-		resultMap:        map[string]*data.Result{},
-		matchDecisionMap: map[string]*data.MatchDecision{},
+		jobOfferMap:                map[string]*data.JobOfferContainer{},
+		resourceOfferMap:           map[string]*data.ResourceOfferContainer{},
+		dealMap:                    map[string]*data.DealContainer{},
+		resultMap:                  map[string]*data.Result{},
+		matchDecisionMap:           map[string]*data.MatchDecision{},
+		allowedResourceProviderMap: map[string]string{},
 	}, nil
 }
 
@@ -79,6 +81,14 @@ func (s *SolverStoreMemory) AddMatchDecision(resourceOffer string, jobOffer stri
 	return decision, nil
 }
 
+func (store *SolverStoreMemory) AddAllowedResourceProvider(resourceProvider string) (string, error) {
+	store.mutex.Lock()
+	defer store.mutex.Unlock()
+	store.allowedResourceProviderMap[resourceProvider] = resourceProvider
+
+	return resourceProvider, nil
+}
+
 func (s *SolverStoreMemory) GetJobOffers(query store.GetJobOffersQuery) ([]data.JobOfferContainer, error) {
 	s.mutex.RLock()
 	defer s.mutex.RUnlock()
@@ -190,6 +200,18 @@ func (s *SolverStoreMemory) GetMatchDecisions() ([]data.MatchDecision, error) {
 	return results, nil
 }
 
+func (store *SolverStoreMemory) GetAllowedResourceProviders() ([]string, error) {
+	store.mutex.RLock()
+	defer store.mutex.RUnlock()
+
+	providers := []string{}
+	for provider := range store.allowedResourceProviderMap {
+		providers = append(providers, provider)
+	}
+
+	return providers, nil
+}
+
 func (s *SolverStoreMemory) GetJobOffer(id string) (*data.JobOfferContainer, error) {
 	s.mutex.RLock()
 	defer s.mutex.RUnlock()
@@ -414,6 +436,13 @@ func (s *SolverStoreMemory) RemoveMatchDecision(resourceOffer string, jobOffer s
 	return nil
 }
 
+func (store *SolverStoreMemory) RemoveAllowedResourceProvider(resourceProvider string) error {
+	store.mutex.Lock()
+	defer store.mutex.Unlock()
+	delete(store.allowedResourceProviderMap, resourceProvider)
+	return nil
+}
+
 // Strictly speaking, the compiler will check the interface
 // implementation without this check. But some code editors
 // report errors more effectively when we have it.