125 lines
3.4 KiB
Go
125 lines
3.4 KiB
Go
package serv
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
|
|
"hkp-clavis/internal/model"
|
|
storeRepo "hkp-clavis/internal/repo/storage"
|
|
service "hkp-clavis/internal/service/storage"
|
|
|
|
"github.com/ProtonMail/go-crypto/openpgp"
|
|
hkp "github.com/emersion/go-openpgp-hkp"
|
|
)
|
|
|
|
type StorageService struct {
|
|
hkp.Adder
|
|
hkp.Lookuper
|
|
// mailService interface{}
|
|
storage storeRepo.StorageRepositotyInterface
|
|
config StorageServiceConfig
|
|
keyManager *model.KeyManager
|
|
}
|
|
|
|
type StorageServiceConfig struct {
|
|
defaultVerify bool
|
|
}
|
|
|
|
func New(storageRepository storeRepo.StorageRepositotyInterface, keyManager *model.KeyManager, defaultVerifyValue bool) service.StorageInterface {
|
|
return StorageService{
|
|
storage: storageRepository,
|
|
keyManager: keyManager,
|
|
config: StorageServiceConfig{
|
|
defaultVerify: defaultVerifyValue,
|
|
},
|
|
|
|
// Allocation manager
|
|
}
|
|
}
|
|
func (s StorageService) Add(ctx context.Context, el openpgp.EntityList) ([]*model.PGPKey, error) {
|
|
pgpKeys, release, err := s.keyManager.ConverterPgpToService(el, s.config.defaultVerify) // Assuming ConverterPgpToService might return an error now.
|
|
defer release()
|
|
|
|
if err != nil {
|
|
return []*model.PGPKey{}, fmt.Errorf("service error: Add: failed to convert PGP entities: %w", err)
|
|
}
|
|
|
|
if len(pgpKeys) == 0 {
|
|
return []*model.PGPKey{}, nil // No keys to add, nothing to do.
|
|
}
|
|
|
|
err = s.storage.AddKey(ctx, pgpKeys) // Pass context here
|
|
if err != nil {
|
|
return []*model.PGPKey{}, fmt.Errorf("service error: Add: failed to add keys to storage: %w", err)
|
|
}
|
|
|
|
return pgpKeys, nil
|
|
}
|
|
|
|
func (s StorageService) Get(ctx context.Context, req *hkp.LookupRequest) (openpgp.EntityList, error) {
|
|
dbKeys, err := s.storage.Index(ctx, req.Search)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("service error: Get: search failed: %w", err)
|
|
}
|
|
|
|
if len(dbKeys) == 0 {
|
|
return nil, storeRepo.ErrKeyNotFound
|
|
}
|
|
|
|
defer s.keyManager.Release(dbKeys...)
|
|
|
|
var finalEntityList openpgp.EntityList
|
|
|
|
for _, dbKey := range dbKeys {
|
|
filteredEntities, err := model.SanitizeAndFilterKey(dbKey)
|
|
if err != nil {
|
|
log.Printf("Warning: Get: failed to sanitize key %s: %v", dbKey.Fingerprint, err)
|
|
continue
|
|
}
|
|
finalEntityList = append(finalEntityList, filteredEntities...)
|
|
}
|
|
|
|
if len(finalEntityList) == 0 {
|
|
return nil, storeRepo.ErrKeyNotFound
|
|
}
|
|
|
|
return finalEntityList, nil
|
|
}
|
|
|
|
func (s StorageService) Index(ctx context.Context, req *hkp.LookupRequest) ([]hkp.IndexKey, error) {
|
|
dbKeys, err := s.storage.Index(ctx, req.Search)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("service error: Index: db index request for '%s': %w", req.Search, err)
|
|
}
|
|
defer s.keyManager.Release(dbKeys...)
|
|
|
|
if len(dbKeys) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
var respIndex []hkp.IndexKey
|
|
for _, dbKey := range dbKeys {
|
|
filteredEntity, err := model.SanitizeAndFilterKey(dbKey)
|
|
if err != nil {
|
|
log.Printf("Warning: service error: Index: failed to sanitize and filter key %s: %v, skipping.", dbKey.Fingerprint, err)
|
|
continue // Skip this problematic key
|
|
}
|
|
|
|
for _, fpk := range filteredEntity {
|
|
idxKey, err := hkp.IndexKeyFromEntity(fpk)
|
|
if err != nil {
|
|
log.Printf("Warning: service error: Index: failed to convert entity %s to IndexKey: %v, skipping.", dbKey.Fingerprint, err)
|
|
continue
|
|
}
|
|
respIndex = append(respIndex, *idxKey)
|
|
}
|
|
}
|
|
|
|
if len(respIndex) == 0 {
|
|
return nil, fmt.Errorf("service error: Index: no valid index keys found after processing for '%s': %w", req.Search, storeRepo.ErrKeyNotFound)
|
|
}
|
|
|
|
return respIndex, nil
|
|
}
|