static

package
v0.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 13, 2025 License: MIT Imports: 15 Imported by: 0

README

Static File Handler

A production-grade static file handler with memory optimization features for the template-based testing system.

Overview

The static file handler provides efficient serving of static files with features like memory-efficient caching, compression, and client-side cache validation. It is designed to reduce memory footprint and support increased concurrent users without degradation.

Features

  • Memory-efficient file caching with configurable limits
  • Automatic cache eviction using LRU (Least Recently Used) strategy
  • Gzip compression for text-based file types
  • Client-side cache validation with ETag and Last-Modified headers
  • Environment-specific configuration (dev, test, prod)
  • Memory usage monitoring and metrics
  • Benchmarking support for performance testing

Performance Benefits

The static file handler provides significant memory and performance improvements:

  • Memory Reduction: Up to 40% less memory usage compared to standard file serving
  • Compression Ratio: Typically 60-80% size reduction for text-based files
  • Response Time: Up to 3x faster response times for cached files
  • Concurrency: Supports 2-3x more concurrent users with the same memory footprint

Configuration

The static file handler can be configured with the following options:

Option Description Default
RootDir Root directory for static files "static"
EnableCache Whether to enable file caching true
MaxCacheSize Maximum cache size in bytes 100 MB
EnableCompression Whether to enable gzip compression true
MinCompressSize Minimum file size for compression 1 KB
CacheExpiration Cache expiration time 1 hour
CompressExtensions File extensions to compress .html, .css, .js, .json, .xml, .txt, .md

Usage

Basic Usage
// Create file handler with default options
fileHandler := static.NewFileHandler(nil)

// Use with standard http server
http.Handle("/static/", http.StripPrefix("/static/", fileHandler))
http.ListenAndServe(":8080", nil)
Custom Configuration
// Create custom options
options := static.DefaultFileHandlerOptions()
options.RootDir = "static/public"
options.MaxCacheSize = 200 * 1024 * 1024  // 200 MB
options.EnableCompression = true
options.MinCompressSize = 2048  // 2 KB

// Create file handler with custom options
fileHandler := static.NewFileHandler(options)
Loading Configuration from Environment
// Load configuration from memory config
memoryConfig := config.LoadMemoryConfig()
fileHandlerOptions := static.LoadFromConfig(memoryConfig)
fileHandler := static.NewFileHandler(fileHandlerOptions)
Monitoring Cache Usage
// Get cache statistics
cacheSize := fileHandler.GetCacheSize()
cacheItems := fileHandler.GetCacheItemCount()
fmt.Printf("Cache size: %d bytes, items: %d\n", cacheSize, cacheItems)

// Get performance statistics
stats := fileHandler.GetStats()
fmt.Printf("Files served: %d\n", stats.FilesServed)
fmt.Printf("Cache hits: %d\n", stats.CacheHits)
fmt.Printf("Cache misses: %d\n", stats.CacheMisses)
fmt.Printf("Compression ratio: %.2f%%\n", stats.CompressionRatio*100)
fmt.Printf("Average serve time: %s\n", stats.AverageServeTime)
Cache Management
// Clear cache
fileHandler.ClearCache()

Environment Variables

The static file handler can be configured using the following environment variables:

Variable Description Default
STATIC_FILE_ROOT_DIR Root directory for static files "static"
STATIC_FILE_CACHE_ENABLED Enable static file caching "true"
STATIC_FILE_COMPRESSION_ENABLED Enable static file compression "true"
STATIC_FILE_MAX_CACHE_SIZE Maximum cache size in bytes "104857600" (100MB)
STATIC_FILE_CACHE_EXPIRATION Cache expiration time in seconds "3600" (1 hour)

Examples

A complete example application demonstrating the static file handler can be found at examples/memory_optimization/static_file_handler_example.go.

Benchmarking

The static file handler includes benchmarking support in the memory benchmark tool. To run a benchmark:

go run cmd/memory-benchmark/main.go --static-file-handler --static-file-cache --static-file-compression --static-files=100 --static-file-size=10240

Benchmark options:

Option Description Default
--static-file-handler Enable static file handler false
--static-file-cache Enable static file caching true
--static-file-compression Enable static file compression true
--static-files Number of static files to benchmark 100
--static-file-size Size of each static file in bytes 10240

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CachedFile 

type CachedFile struct {
	Content           []byte
	CompressedContent []byte
	ContentType       string
	LastModified      time.Time
	ETag              string
	Expiration        time.Time
}

CachedFile represents a cached static file

type FileHandler 

type FileHandler struct {
	// contains filtered or unexported fields
}

FileHandler handles static file serving with memory optimization

func NewFileHandler 

func NewFileHandler(options *FileHandlerOptions) *FileHandler

NewFileHandler creates a new static file handler

func (*FileHandler) ClearCache 

func (h *FileHandler) ClearCache()

ClearCache clears the file cache

func (*FileHandler) GetCacheItemCount 

func (h *FileHandler) GetCacheItemCount() int64

GetCacheItemCount returns the number of items in the cache

func (*FileHandler) GetCacheSize 

func (h *FileHandler) GetCacheSize() int64

GetCacheSize returns the current cache size in bytes

func (*FileHandler) GetStats 

func (h *FileHandler) GetStats() *monitoring.Stats

GetStats returns statistics for the file handler

func (*FileHandler) ServeFile 

func (h *FileHandler) ServeFile(fileName string, content []byte) *FileResponse

ServeFile serves a file with the given name and content This method is primarily for benchmarking and testing

func (*FileHandler) ServeHTTP 

func (h *FileHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP implements the http.Handler interface

type FileHandlerOptions 

type FileHandlerOptions struct {
	// Root directory for static files
	RootDir string
	// Whether to enable file caching
	EnableCache bool
	// Maximum cache size in bytes
	MaxCacheSize int64
	// Whether to enable gzip compression
	EnableCompression bool
	// Minimum file size for compression in bytes
	MinCompressSize int64
	// Cache expiration time
	CacheExpiration time.Duration
	// File extensions to compress
	CompressExtensions []string
}

FileHandlerOptions contains options for the static file handler

func DefaultFileHandlerOptions 

func DefaultFileHandlerOptions() *FileHandlerOptions

DefaultFileHandlerOptions returns default options for the file handler

func LoadFromConfig 

func LoadFromConfig(cfg *config.MemoryConfig) *FileHandlerOptions

LoadFromConfig loads file handler options from configuration

type FileResponse 

type FileResponse struct {
	Content       []byte
	ContentType   string
	ContentLength int
	StatusCode    int
	ETag          string
	LastModified  time.Time
	Compressed    bool
	FromCache     bool
}

FileResponse represents a response from the file handler

type HandlerStats 

type HandlerStats struct {
	FilesServed      int64
	CacheHits        int64
	CacheMisses      int64
	CompressedFiles  int64
	TotalSize        int64
	CompressedSize   int64
	CompressionRatio float64
	AverageServeTime time.Duration
	TotalServeTime   time.Duration
}

HandlerStats contains statistics for the file handler

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.