httpfile - file.go

  // Package httpfile provides an easy way to create HTTP handlers that respond
  // with static data, providing compressed data when the client accepts it.
  package httpfile // import "vimagination.zapto.org/httpfile"
  
  import (
  	"bytes"
  	"compress/gzip"
  	"io"
  	"io/fs"
  	"maps"
  	"net/http"
  	"strconv"
  	"sync"
  	"time"
  
  	"vimagination.zapto.org/httpencoding"
  )
  
  // Type file represents an http.Handler upon which you can set static data.
  type File struct {
  	name    string
  	mu      sync.RWMutex
  	modtime time.Time
  	optionData
  }
  
  type optionData struct {
  	compressors map[httpencoding.Encoding]func([]byte) []byte
  	data        map[httpencoding.Encoding][]byte
  	encodings   []httpencoding.Encoding
  	parallel    bool
  }
  
  func identityEncode(b []byte) []byte {
  	return append(make([]byte, 0, len(b)), b...)
  }
  
  var (
  	defaultCompressors = map[httpencoding.Encoding]func(b []byte) []byte{
  		"":     identityEncode,
  		"gzip": gzipEncode(gzip.DefaultCompression),
  	}
  	defaultData      = map[httpencoding.Encoding][]byte{"": nil, "gzip": emptyGzip[:]}
  	defaultEncodings = []httpencoding.Encoding{"", "gzip"}
  )
  
  // New creates a new File with the given name, which is used to apply
  // Content-Type headers.
  //
  // Options can be passed in to specify which compressed forms the data will be
  // stored in and given to the HTTP client when requested.
  //
  // When no options are given, gzip compression will be enabled with the default
  // compression level.
  //
  // The order the encoding Options are given in will determine how equally
  // weighted encodings are prioritised with the earlier options being given
  // priority over later options.
  func New(name string, opts ...Option) *File {
  	f := &File{name: name}
  
  	if len(opts) == 0 {
  		f.optionData.compressors = defaultCompressors
  		f.optionData.data = maps.Clone(defaultData)
  		f.optionData.encodings = defaultEncodings
  	} else {
  		f.optionData.compressors = map[httpencoding.Encoding]func([]byte) []byte{"": identityEncode}
  		f.optionData.data = map[httpencoding.Encoding][]byte{"": nil}
  
  		for _, opt := range opts {
  			opt(&f.optionData)
  		}
  
  		f.optionData.encodings = append(f.optionData.encodings, "")
  	}
  
  	f.modtime = time.Now()
  
  	return f
  }
  
  // NewWithData create a new File with the given name, and sets the initial
  // uncompressed data to that provided.
  //
  // See the New function for how to use the Options.
  func NewWithData(name string, data []byte, opts ...Option) *File {
  	f := New(name, opts...)
  	w := Writer{
  		file: f,
  		data: data,
  	}
  
  	w.Close()
  
  	return f
  }
  
  // ServeHTTP implements the http.Handler interface.
  func (f *File) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  	enc, ok := httpencoding.Negotiate(r, f.encodings...)
  	if !ok {
  		httpencoding.InvalidEncoding(w)
  
  		return
  	}
  
  	modtime := f.modtime
  
  	f.mu.RLock()
  	data := f.data[enc]
  	f.mu.RUnlock()
  
  	buf := bytes.NewReader(data)
  
  	if enc != "" {
  		w.Header().Add("Content-Encoding", string(enc))
  
  		w = &wrapResponseWriter{
  			ResponseWriter: w,
  			size:           int64(len(data)),
  		}
  	}
  
  	http.ServeContent(w, r, f.name, modtime, buf)
  }
  
  type wrapResponseWriter struct {
  	http.ResponseWriter
  	size int64
  }
  
  func (w *wrapResponseWriter) WriteHeader(code int) {
  	if w.Header().Get("Content-Length") == "" {
  		w.Header().Set("Content-Length", strconv.FormatInt(w.size, 10))
  	}
  
  	w.ResponseWriter.WriteHeader(code)
  }
  
  // ReadFrom reads all of the data from io.Reader and applies it to the file,
  // overwriting any existing data and setting the modtime to Now.
  func (f *File) ReadFrom(r io.Reader) (int64, error) {
  	file := f.Create()
  	defer file.Close()
  
  	return io.Copy(file, r)
  }
  
  // WriteTo writes the uncompressed data to the given writer.
  func (f *File) WriteTo(w io.Writer) (int64, error) {
  	f.mu.RLock()
  	data := f.data[""]
  	f.mu.RUnlock()
  
  	n, err := w.Write(data)
  
  	return int64(n), err
  }
  
  // Chtime sets the modtime to the given time.
  func (f *File) Chtime(t time.Time) {
  	f.mu.Lock()
  	f.modtime = t
  	f.mu.Unlock()
  }
  
  // Name returns the name given during File creation.
  func (f *File) Name() string {
  	return f.name
  }
  
  // A Writer is bound to the File is was created from, buffering data that is
  // written to it. Upon Closing, that data will be compressed and both the
  // uncompressed and compressed data will be replaced on the File.
  type Writer struct {
  	file *File
  	data []byte
  }
  
  // Create opens a Writer that can be used to write the data for the File. Close
  // must be called on the resulting Writer for the data to be accepted.
  func (f *File) Create() *Writer {
  	return &Writer{
  		file: f,
  	}
  }
  
  // Write is an implementation of the io.Writer interface.
  func (f *Writer) Write(p []byte) (int, error) {
  	if f.file == nil {
  		return 0, fs.ErrClosed
  	}
  
  	f.data = append(f.data, p...)
  
  	return len(p), nil
  }
  
  // WriteString is an implementation of the io.StringWriter interface.
  func (f *Writer) WriteString(str string) (int, error) {
  	if f.file == nil {
  		return 0, fs.ErrClosed
  	}
  
  	f.data = append(f.data, str...)
  
  	return len(str), nil
  }
  
  // Close is an implementation of the io.Close interface.
  //
  // This method must be called for the written data to be accepted on the File.
  func (f *Writer) Close() error {
  	if f.file == nil {
  		return fs.ErrClosed
  	}
  
  	var encodings map[httpencoding.Encoding][]byte
  
  	if f.file.parallel {
  		encodings = f.processEncodingsParallel()
  	} else {
  		encodings = f.processEncodings()
  	}
  
  	f.file.mu.Lock()
  	f.file.modtime = time.Now()
  	f.file.data = encodings
  	f.file.mu.Unlock()
  
  	*f = Writer{}
  
  	return nil
  }
  
  func (f *Writer) processEncodings() map[httpencoding.Encoding][]byte {
  	encodings := make(map[httpencoding.Encoding][]byte, len(f.file.encodings))
  
  	for _, enc := range f.file.encodings {
  		encodings[enc] = f.file.compressors[enc](f.data)
  	}
  
  	return encodings
  }
  
  func (f *Writer) processEncodingsParallel() map[httpencoding.Encoding][]byte {
  	encodings := make(map[httpencoding.Encoding][]byte, len(f.file.encodings))
  	tEncodings := make([][]byte, len(f.file.encodings))
  
  	var wg sync.WaitGroup
  
  	wg.Add(len(f.file.encodings))
  
  	for n, enc := range f.file.encodings {
  		go func(n int, enc httpencoding.Encoding) {
  			tEncodings[n] = f.file.compressors[enc](f.data)
  
  			wg.Done()
  		}(n, enc)
  	}
  
  	wg.Wait()
  
  	for n, enc := range f.file.encodings {
  		encodings[enc] = tEncodings[n]
  	}
  
  	return encodings
  }