goldsmith/context.go

170 lines
4.1 KiB
Go
Raw Normal View History

2015-12-18 08:03:30 +00:00
package goldsmith
import (
2018-12-08 19:18:51 +00:00
"bytes"
"errors"
"io"
2015-12-20 14:18:58 +00:00
"os"
2022-05-16 03:26:09 +00:00
"path/filepath"
2015-12-20 08:38:53 +00:00
"runtime"
2015-12-18 08:03:30 +00:00
"sync"
2018-12-08 19:18:51 +00:00
"time"
2015-12-18 08:03:30 +00:00
)
2019-04-08 01:02:57 +00:00
// Context corresponds to the current link in the chain and provides methods
// that enable plugins to inject new files into the chain.
2018-12-08 19:18:51 +00:00
type Context struct {
goldsmith *Goldsmith
plugin Plugin
2018-12-08 19:18:51 +00:00
2021-05-01 22:12:50 +00:00
filtersExt filterStack
filtersInt filterStack
2021-04-12 02:13:59 +00:00
2021-05-01 22:12:50 +00:00
threads int
index int
2021-05-01 22:12:50 +00:00
filesIn chan *File
filesOut chan *File
2018-12-08 19:18:51 +00:00
}
2019-04-08 01:02:57 +00:00
// CreateFileFrom data creates a new file instance from the provided data buffer.
func (self *Context) CreateFileFromReader(sourcePath string, reader io.Reader) (*File, error) {
2023-11-11 19:04:37 +00:00
data, err := io.ReadAll(reader)
if err != nil {
return nil, err
}
file := &File{
relPath: sourcePath,
props: make(map[string]Prop),
modTime: time.Now(),
size: int64(len(data)),
reader: bytes.NewReader(data),
index: self.index,
2018-12-08 19:18:51 +00:00
}
return file, nil
2018-12-08 19:18:51 +00:00
}
2019-04-08 01:02:57 +00:00
// CreateFileFromAsset creates a new file instance from the provided file path.
func (self *Context) CreateFileFromAsset(sourcePath, dataPath string) (*File, error) {
2022-05-16 03:26:09 +00:00
if filepath.IsAbs(sourcePath) {
return nil, errors.New("source paths must be relative")
}
if filepath.IsAbs(dataPath) {
return nil, errors.New("data paths must be relative")
}
2018-12-08 19:18:51 +00:00
info, err := os.Stat(dataPath)
if err != nil {
return nil, err
}
if info.IsDir() {
return nil, errors.New("assets must be files")
}
file := &File{
relPath: sourcePath,
props: make(map[string]Prop),
modTime: info.ModTime(),
size: info.Size(),
dataPath: dataPath,
index: self.index,
2018-12-08 19:18:51 +00:00
}
return file, nil
}
2019-04-08 01:02:57 +00:00
// DispatchFile causes the file to get passed to the next link in the chain.
func (self *Context) DispatchFile(file *File) {
self.filesOut <- file
2018-12-08 19:18:51 +00:00
}
2019-04-08 01:02:57 +00:00
// DispatchAndCacheFile caches the file data (excluding the metadata), taking
// dependencies on any input files that are needed to generate it, and then
// passes it to the next link in the chain.
func (self *Context) DispatchAndCacheFile(outputFile *File, inputFiles ...*File) {
if self.goldsmith.cache != nil {
self.goldsmith.cache.storeFile(self, outputFile, inputFiles)
2021-05-01 22:12:50 +00:00
}
self.filesOut <- outputFile
2015-12-18 08:03:30 +00:00
}
2019-04-08 01:02:57 +00:00
// RetrieveCachedFile looks up file data (excluding the metadata), given an
// output path and any input files that are needed to generate it. The function
// will return nil if the desired file is not found in the cache.
func (self *Context) RetrieveCachedFile(outputPath string, inputFiles ...*File) *File {
2021-05-01 22:12:50 +00:00
var outputFile *File
if self.goldsmith.cache != nil {
outputFile, _ = self.goldsmith.cache.retrieveFile(self, outputPath, inputFiles)
2021-05-01 22:12:50 +00:00
}
return outputFile
2018-12-08 19:18:51 +00:00
}
2021-04-12 02:13:59 +00:00
// Specify internal filter(s) that exclude files from being processed.
func (self *Context) Filter(filters ...Filter) *Context {
for _, filter := range filters {
self.filtersInt.push(filter, self.index)
}
return self
2021-05-01 22:12:50 +00:00
}
// Specify the maximum number of threads used for processing.
func (self *Context) Threads(threads int) *Context {
self.threads = threads
return self
2021-04-12 02:13:59 +00:00
}
func (self *Context) step() {
defer close(self.filesOut)
2015-12-18 08:03:30 +00:00
if initializer, ok := self.plugin.(Initializer); ok {
if err := initializer.Initialize(self); err != nil {
self.goldsmith.fault(self.plugin.Name(), nil, err)
2015-12-20 08:38:53 +00:00
return
2015-12-18 08:03:30 +00:00
}
}
if self.filesIn != nil {
processor, _ := self.plugin.(Processor)
2016-07-10 20:05:23 +00:00
threads := self.threads
2021-05-01 22:12:50 +00:00
if threads < 1 {
threads = runtime.NumCPU()
}
2016-01-10 11:17:35 +00:00
var wg sync.WaitGroup
2021-05-01 22:12:50 +00:00
for i := 0; i < threads; i++ {
2016-01-10 11:17:35 +00:00
wg.Add(1)
go func() {
defer wg.Done()
for inputFile := range self.filesIn {
if processor != nil && self.filtersInt.accept(inputFile) && self.filtersExt.accept(inputFile) {
2023-11-11 19:04:37 +00:00
if _, err := inputFile.Seek(0, io.SeekStart); err != nil {
self.goldsmith.fault("core", inputFile, err)
2016-01-10 11:17:35 +00:00
}
if err := processor.Process(self, inputFile); err != nil {
self.goldsmith.fault(self.plugin.Name(), inputFile, err)
2016-01-10 11:17:35 +00:00
}
} else {
self.filesOut <- inputFile
2015-12-20 08:38:53 +00:00
}
2015-12-18 08:03:30 +00:00
}
2016-01-10 11:17:35 +00:00
}()
}
2016-01-10 11:17:35 +00:00
wg.Wait()
2015-12-18 08:03:30 +00:00
}
if finalizer, ok := self.plugin.(Finalizer); ok {
if err := finalizer.Finalize(self); err != nil {
self.goldsmith.fault(self.plugin.Name(), nil, err)
2015-12-18 08:03:30 +00:00
}
2015-12-19 11:51:23 +00:00
}
2015-12-18 08:03:30 +00:00
}