mirror of
https://github.com/bitechdev/ResolveSpec.git
synced 2025-12-31 00:34:25 +00:00
120 lines
3.0 KiB
Go
120 lines
3.0 KiB
Go
package providers
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bytes"
|
|
"embed"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"sync"
|
|
|
|
"github.com/bitechdev/ResolveSpec/pkg/server/zipfs"
|
|
)
|
|
|
|
// EmbedFSProvider serves files from an embedded filesystem.
|
|
// It supports both direct embedded directories and embedded zip files.
|
|
type EmbedFSProvider struct {
|
|
embedFS *embed.FS
|
|
zipFile string // Optional: path within embedded FS to zip file
|
|
zipReader *zip.Reader
|
|
fs fs.FS
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
// NewEmbedFSProvider creates a new EmbedFSProvider.
|
|
// If zipFile is empty, the embedded FS is used directly.
|
|
// If zipFile is specified, it's treated as a path to a zip file within the embedded FS.
|
|
func NewEmbedFSProvider(embedFS fs.FS, zipFile string) (*EmbedFSProvider, error) {
|
|
if embedFS == nil {
|
|
return nil, fmt.Errorf("embedded filesystem cannot be nil")
|
|
}
|
|
|
|
// Try to cast to *embed.FS for tracking purposes
|
|
var embedFSPtr *embed.FS
|
|
if efs, ok := embedFS.(*embed.FS); ok {
|
|
embedFSPtr = efs
|
|
}
|
|
|
|
provider := &EmbedFSProvider{
|
|
embedFS: embedFSPtr,
|
|
zipFile: zipFile,
|
|
}
|
|
|
|
// If zipFile is specified, open it as a zip archive
|
|
if zipFile != "" {
|
|
// Read the zip file from the embedded FS
|
|
// We need to check if the FS supports ReadFile
|
|
var data []byte
|
|
var err error
|
|
|
|
if readFileFS, ok := embedFS.(interface{ ReadFile(string) ([]byte, error) }); ok {
|
|
data, err = readFileFS.ReadFile(zipFile)
|
|
} else {
|
|
// Fall back to Open and reading
|
|
file, openErr := embedFS.Open(zipFile)
|
|
if openErr != nil {
|
|
return nil, fmt.Errorf("failed to open embedded zip file: %w", openErr)
|
|
}
|
|
defer file.Close()
|
|
data, err = io.ReadAll(file)
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read embedded zip file: %w", err)
|
|
}
|
|
|
|
// Create a zip reader from the data
|
|
reader := bytes.NewReader(data)
|
|
zipReader, err := zip.NewReader(reader, int64(len(data)))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create zip reader: %w", err)
|
|
}
|
|
|
|
provider.zipReader = zipReader
|
|
provider.fs = zipfs.NewZipFS(zipReader)
|
|
} else {
|
|
// Use the embedded FS directly
|
|
provider.fs = embedFS
|
|
}
|
|
|
|
return provider, nil
|
|
}
|
|
|
|
// Open opens the named file from the embedded filesystem.
|
|
func (p *EmbedFSProvider) Open(name string) (fs.File, error) {
|
|
p.mu.RLock()
|
|
defer p.mu.RUnlock()
|
|
|
|
if p.fs == nil {
|
|
return nil, fmt.Errorf("embedded filesystem is closed")
|
|
}
|
|
|
|
return p.fs.Open(name)
|
|
}
|
|
|
|
// Close releases any resources held by the provider.
|
|
// For embedded filesystems, this is mostly a no-op since Go manages the lifecycle.
|
|
func (p *EmbedFSProvider) Close() error {
|
|
p.mu.Lock()
|
|
defer p.mu.Unlock()
|
|
|
|
// Clear references to allow garbage collection
|
|
p.fs = nil
|
|
p.zipReader = nil
|
|
|
|
return nil
|
|
}
|
|
|
|
// Type returns "embed" or "embed-zip" depending on the configuration.
|
|
func (p *EmbedFSProvider) Type() string {
|
|
if p.zipFile != "" {
|
|
return "embed-zip"
|
|
}
|
|
return "embed"
|
|
}
|
|
|
|
// ZipFile returns the path to the zip file within the embedded FS, if any.
|
|
func (p *EmbedFSProvider) ZipFile() string {
|
|
return p.zipFile
|
|
}
|