absnfs

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

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

type AuthContext struct {
	ClientIP   string             // Client IP address
	ClientPort int                // Client port number
	Credential *RPCCredential     // RPC credential
	AuthSys    *AuthSysCredential // Parsed AUTH_SYS credential (if applicable)
	ClientCert *x509.Certificate  // Client certificate (if TLS with client auth)
	TLSEnabled bool               // Whether this connection is using TLS
}

type AuthResult struct {
	Allowed bool   // Whether the request is allowed
	UID     uint32 // Effective UID after squashing
	GID     uint32 // Effective GID after squashing
	Reason  string // Reason for denial (if not allowed)
}

type AuthSysCredential struct {
	Stamp       uint32   // Arbitrary ID which the client may generate
	MachineName string   // Name of the client machine (or empty string)
	UID         uint32   // Caller's effective user ID
	GID         uint32   // Caller's effective group ID
	AuxGIDs     []uint32 // Auxiliary group IDs
}

type Batch struct {
	Type      BatchType       // Type of operations in this batch
	Requests  []*BatchRequest // Requests in this batch
	MaxSize   int             // Maximum number of requests in this batch
	ReadyTime time.Time       // Time when this batch should be processed
	// contains filtered or unexported fields
}

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

type BatchRequest struct {
	Type       BatchType         // Type of operation
	FileHandle uint64            // File handle for the operation
	Offset     int64             // Offset for read/write operations
	Length     int               // Length for read/write operations
	Data       []byte            // Data for write operations
	Time       time.Time         // Time the request was added to the batch
	ResultChan chan *BatchResult // Channel to send results back to caller
	Context    context.Context   // Context for cancellation
}

type BatchResult struct {
	Data   []byte // Data for read operations
	Error  error  // Error if any occurred
	Status uint32 // NFS status code
}

type BatchType int

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

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

type CreateArgs struct {
	Where DirOpArg
	Mode  uint32
}

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

type DirOpArg struct {
	Handle FileHandle
	Name   string
}

type Entry struct {
	FileId  uint64
	Name    string
	Cookie  uint64
	NextObj *Entry
}

type ExportOptions struct {
	ReadOnly    bool     // Export as read-only
	Secure      bool     // Require secure ports (<1024)
	AllowedIPs  []string // List of allowed client IPs/subnets
	Squash      string   // User mapping (root/all/none)
	Async       bool     // Allow async writes
	MaxFileSize int64    // Maximum file size

	// TransferSize controls the maximum size in bytes of read/write transfers
	// Larger values may improve performance but require more memory
	// Default: 65536 (64KB)
	TransferSize int

	// EnableReadAhead enables read-ahead buffering for improved sequential read performance
	// When a client reads a file sequentially, the server prefetches additional data
	// Default: true
	EnableReadAhead bool

	// ReadAheadSize controls the size in bytes of the read-ahead buffer
	// Only applicable when EnableReadAhead is true
	// Default: 262144 (256KB)
	ReadAheadSize int

	// ReadAheadMaxFiles controls the maximum number of files that can have active read-ahead buffers
	// Helps limit memory usage by read-ahead buffering
	// Default: 100 files
	ReadAheadMaxFiles int

	// ReadAheadMaxMemory controls the maximum amount of memory in bytes that can be used for read-ahead buffers
	// Once this limit is reached, least recently used buffers will be evicted
	// Default: 104857600 (100MB)
	ReadAheadMaxMemory int64

	// AttrCacheTimeout controls how long file attributes are cached
	// Longer timeouts improve performance but may cause clients to see stale data
	// Default: 5 * time.Second
	AttrCacheTimeout time.Duration

	// AttrCacheSize controls the maximum number of entries in the attribute cache
	// Larger values improve performance but consume more memory
	// Default: 10000 entries
	AttrCacheSize int

	// CacheNegativeLookups enables caching of failed lookups (file not found)
	// This can significantly reduce filesystem load for repeated lookups of non-existent files
	// Negative cache entries use a shorter TTL than positive entries
	// Default: false (disabled)
	CacheNegativeLookups bool

	// NegativeCacheTimeout controls how long negative cache entries are kept
	// Shorter timeouts reduce the chance of stale negative cache entries
	// Only applicable when CacheNegativeLookups is true
	// Default: 5 * time.Second
	NegativeCacheTimeout time.Duration

	// EnableDirCache enables caching of directory entries for improved performance
	// When enabled, directory listings are cached to reduce filesystem calls
	// Default: false (disabled)
	EnableDirCache bool

	// DirCacheTimeout controls how long directory entries are cached
	// Longer timeouts improve performance but may cause clients to see stale directory listings
	// Only applicable when EnableDirCache is true
	// Default: 10 * time.Second
	DirCacheTimeout time.Duration

	// DirCacheMaxEntries controls the maximum number of directories that can be cached
	// Helps limit memory usage by directory entry caching
	// Only applicable when EnableDirCache is true
	// Default: 1000 directories
	DirCacheMaxEntries int

	// DirCacheMaxDirSize controls the maximum number of entries in a single directory that will be cached
	// Directories with more entries than this will not be cached to prevent memory issues
	// Only applicable when EnableDirCache is true
	// Default: 10000 entries per directory
	DirCacheMaxDirSize int

	// AdaptToMemoryPressure enables automatic cache reduction when system memory is under pressure
	// When enabled, the server will periodically check system memory usage and reduce cache sizes
	// when memory usage exceeds MemoryHighWatermark, until usage falls below MemoryLowWatermark
	// Default: false (disabled)
	AdaptToMemoryPressure bool

	// MemoryHighWatermark defines the threshold (as a fraction of total memory) at which
	// memory pressure reduction actions will be triggered
	// Only applicable when AdaptToMemoryPressure is true
	// Valid range: 0.0 to 1.0 (0% to 100% of total memory)
	// Default: 0.8 (80% of total memory)
	MemoryHighWatermark float64

	// MemoryLowWatermark defines the target memory usage (as a fraction of total memory)
	// that the server will try to achieve when reducing cache sizes in response to memory pressure
	// Only applicable when AdaptToMemoryPressure is true
	// Valid range: 0.0 to MemoryHighWatermark
	// Default: 0.6 (60% of total memory)
	MemoryLowWatermark float64

	// MemoryCheckInterval defines how frequently memory usage is checked for pressure detection
	// Only applicable when AdaptToMemoryPressure is true
	// Default: 30 * time.Second
	MemoryCheckInterval time.Duration

	// MaxWorkers controls the maximum number of goroutines used for handling concurrent operations
	// More workers can improve performance for concurrent workloads but consume more CPU resources
	// Default: runtime.NumCPU() * 4 (number of logical CPUs multiplied by 4)
	MaxWorkers int

	// BatchOperations enables grouping of similar operations for improved performance
	// When enabled, the server will attempt to process multiple read/write operations
	// together to reduce context switching and improve throughput
	// Default: true
	BatchOperations bool

	// MaxBatchSize controls the maximum number of operations that can be included in a single batch
	// Larger batches can improve performance but may increase latency for individual operations
	// Only applicable when BatchOperations is true
	// Default: 10 operations
	MaxBatchSize int

	// MaxConnections limits the number of simultaneous client connections
	// Setting to 0 means unlimited connections (limited only by system resources)
	// Default: 100
	MaxConnections int

	// IdleTimeout defines how long to keep inactive connections before closing them
	// This helps reclaim resources from abandoned connections
	// Default: 5 * time.Minute
	IdleTimeout time.Duration

	// TCPKeepAlive enables TCP keep-alive probes on NFS connections
	// Keep-alive helps detect dead connections when clients disconnect improperly
	// Default: true
	TCPKeepAlive bool

	// TCPNoDelay disables Nagle's algorithm on TCP connections to reduce latency
	// This may improve performance for small requests at the cost of increased bandwidth usage
	// Default: true
	TCPNoDelay bool

	// SendBufferSize controls the size of the TCP send buffer in bytes
	// Larger buffers can improve throughput but consume more memory
	// Default: 262144 (256KB)
	SendBufferSize int

	// ReceiveBufferSize controls the size of the TCP receive buffer in bytes
	// Larger buffers can improve throughput but consume more memory
	// Default: 262144 (256KB)
	ReceiveBufferSize int

	// EnableRateLimiting enables rate limiting and DoS protection
	// When enabled, the server will limit requests per IP, per connection, and per operation type
	// Default: true
	EnableRateLimiting bool

	// RateLimitConfig provides detailed rate limiting configuration
	// Only applicable when EnableRateLimiting is true
	// If nil, default configuration will be used
	RateLimitConfig *RateLimiterConfig

	// TLS holds the TLS/SSL configuration for encrypted connections
	// When TLS.Enabled is true, all NFS connections will be encrypted using TLS
	// Provides confidentiality, integrity, and optional mutual authentication
	// If nil, TLS is disabled and connections are unencrypted (default NFSv3 behavior)
	TLS *TLSConfig

	// Log holds the logging configuration for the NFS server
	// When nil, logging is disabled (no-op logger is used)
	// When provided, enables structured logging with configurable level, format, and output
	Log *LogConfig

	// Timeouts controls operation-specific timeout durations
	// When nil, default timeouts are used for all operations
	// Allows fine-grained control over how long each operation type can take
	Timeouts *TimeoutConfig
	// contains filtered or unexported fields
}

type FSInfo struct {
	MaxFileSize    uint64
	SpaceAvail     uint64
	SpaceTotal     uint64
	SpaceFree      uint64
	FileSlotsFree  uint32
	FileSlotsTotal uint32
	Properties     uint32
}

type FSStats struct {
	TotalBytes uint64
	FreeBytes  uint64
	AvailBytes uint64
	TotalFiles uint64
	FreeFiles  uint64
	AvailFiles uint64
	InvarSec   uint32
}

type FileAttribute struct {
	Type                uint32
	Mode                uint32
	Nlink               uint32
	Uid                 uint32
	Gid                 uint32
	Size                uint64
	Used                uint64
	SpecData            [2]uint32
	Fsid                uint64
	Fileid              uint64
	Atime, Mtime, Ctime uint32
}

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

type FileHandle struct {
	Handle uint64
}

type FileHandleMap struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type InvalidFileHandleError struct {
	Handle uint64
	Reason string
}

type LogConfig struct {
	// Level sets the minimum log level to output
	// Valid values: "debug", "info", "warn", "error"
	// Default: "info"
	Level string

	// Format sets the log output format
	// Valid values: "json", "text"
	// Default: "text"
	Format string

	// Output sets the log destination
	// Valid values: "stdout", "stderr", or a file path
	// Default: "stderr"
	Output string

	// LogClientIPs enables logging of client IP addresses
	// When true, client IPs are included in connection and authentication logs
	// Default: false (for privacy)
	LogClientIPs bool

	// LogOperations enables detailed logging of NFS operations
	// When true, logs each NFS operation (LOOKUP, READ, WRITE, etc.) with timing
	// Default: false (reduces log volume)
	LogOperations bool

	// LogFileAccess enables logging of file access patterns
	// When true, logs file opens, closes, and access patterns
	// Default: false (reduces log volume)
	LogFileAccess bool

	// MaxSize defines the maximum size of log file in megabytes before rotation
	// NOTE: File rotation is not yet implemented. This field is reserved for future enhancement.
	// Only applicable when Output is a file path
	// Default: 100 MB
	MaxSize int

	// MaxBackups defines the maximum number of old log files to retain
	// NOTE: File rotation is not yet implemented. This field is reserved for future enhancement.
	// Only applicable when Output is a file path
	// Default: 3
	MaxBackups int

	// MaxAge defines the maximum number of days to retain old log files
	// NOTE: File rotation is not yet implemented. This field is reserved for future enhancement.
	// Only applicable when Output is a file path
	// Default: 28 days
	MaxAge int

	// Compress enables gzip compression of rotated log files
	// NOTE: File rotation is not yet implemented. This field is reserved for future enhancement.
	// Only applicable when Output is a file path
	// Default: false
	Compress bool
}

type LogField struct {
	Key   string
	Value interface{}
}

type Logger interface {
	// Debug logs a debug-level message with optional structured fields
	Debug(msg string, fields ...LogField)

	// Info logs an info-level message with optional structured fields
	Info(msg string, fields ...LogField)

	// Warn logs a warning-level message with optional structured fields
	Warn(msg string, fields ...LogField)

	// Error logs an error-level message with optional structured fields
	Error(msg string, fields ...LogField)
}

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

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

type NFSAttrs struct {
	Mode   os.FileMode
	Size   int64
	FileId uint64 // Unique file identifier (inode number)

	Uid uint32
	Gid uint32
	// contains filtered or unexported fields
}

type NFSMetrics struct {
	// Operation counts
	TotalOperations   uint64
	ReadOperations    uint64
	WriteOperations   uint64
	LookupOperations  uint64
	GetAttrOperations uint64
	CreateOperations  uint64
	RemoveOperations  uint64
	RenameOperations  uint64
	MkdirOperations   uint64
	RmdirOperations   uint64
	ReaddirOperations uint64
	AccessOperations  uint64

	// Latency metrics
	AvgReadLatency  time.Duration
	AvgWriteLatency time.Duration
	MaxReadLatency  time.Duration
	MaxWriteLatency time.Duration
	P95ReadLatency  time.Duration
	P95WriteLatency time.Duration

	// Cache metrics
	CacheHitRate         float64
	ReadAheadHitRate     float64
	AttrCacheSize        int
	AttrCacheCapacity    int
	ReadAheadBufferSize  int64
	DirCacheHitRate      float64
	NegativeCacheSize    int     // Number of negative cache entries
	NegativeCacheHitRate float64 // Hit rate for negative cache lookups

	// Connection metrics
	ActiveConnections   int
	TotalConnections    uint64
	RejectedConnections uint64

	// TLS metrics
	TLSHandshakes          uint64 // Successful TLS handshakes
	TLSHandshakeFailures   uint64 // Failed TLS handshakes
	TLSClientCertProvided  uint64 // Connections with client certificates
	TLSClientCertValidated uint64 // Successfully validated client certificates
	TLSClientCertRejected  uint64 // Rejected client certificates
	TLSSessionReused       uint64 // TLS session resumptions
	TLSVersion12           uint64 // Connections using TLS 1.2
	TLSVersion13           uint64 // Connections using TLS 1.3

	// Error metrics
	ErrorCount        uint64
	AuthFailures      uint64
	AccessViolations  uint64
	StaleHandles      uint64
	ResourceErrors    uint64
	RateLimitExceeded uint64

	// Timeout metrics
	ReadTimeouts    uint64
	WriteTimeouts   uint64
	LookupTimeouts  uint64
	ReaddirTimeouts uint64
	CreateTimeouts  uint64
	RemoveTimeouts  uint64
	RenameTimeouts  uint64
	HandleTimeouts  uint64
	TotalTimeouts   uint64

	// Time-based metrics
	StartTime     time.Time
	UptimeSeconds int64
}

type NFSNode struct {
	absfs.SymlinkFileSystem
	// contains filtered or unexported fields
}

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

type NotSupportedError struct {
	Operation string
	Reason    string
}

type OperationType string

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

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

type PortMapping struct {
	Program  uint32
	Version  uint32
	Protocol uint32 // IPPROTO_TCP or IPPROTO_UDP
	Port     uint32
}

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

type RPCCall struct {
	Header     RPCMsgHeader
	Credential RPCCredential
	Verifier   RPCVerifier
}

type RPCCredential struct {
	Flavor uint32
	Body   []byte
}

type RPCError struct {
	Status uint32
	Msg    string
}

type RPCMsgHeader struct {
	Xid        uint32
	MsgType    uint32
	RPCVersion uint32
	Program    uint32
	Version    uint32
	Procedure  uint32
}

type RPCReply struct {
	Header       RPCMsgHeader
	Status       uint32 // reply_stat: MSG_ACCEPTED or MSG_DENIED
	AcceptStatus uint32 // accept_stat: SUCCESS, PROG_UNAVAIL, etc. (only when Status == MSG_ACCEPTED)
	Verifier     RPCVerifier
	Data         interface{}
}

type RPCVerifier struct {
	Flavor uint32
	Body   []byte
}

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

type RateLimiterConfig struct {
	// Global limits
	GlobalRequestsPerSecond int // Maximum requests per second across all clients

	// Per-IP limits
	PerIPRequestsPerSecond int // Maximum requests per second per IP
	PerIPBurstSize         int // Burst allowance per IP

	// Per-connection limits
	PerConnectionRequestsPerSecond int // Maximum requests per second per connection
	PerConnectionBurstSize         int // Burst allowance per connection

	// Per-operation type limits
	ReadLargeOpsPerSecond  int // Large reads (>64KB) per second per IP
	WriteLargeOpsPerSecond int // Large writes (>64KB) per second per IP
	ReaddirOpsPerSecond    int // READDIR operations per second per IP

	// Mount operation limits
	MountOpsPerMinute int // MOUNT operations per minute per IP

	// File handle limits
	FileHandlesPerIP  int // Maximum file handles per IP
	FileHandlesGlobal int // Maximum file handles globally

	// Cleanup
	CleanupInterval time.Duration // How often to cleanup old entries
}

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

type ReadArgs struct {
	Handle FileHandle
	Offset uint64
	Count  uint32
}

type ReadDirArgs struct {
	Handle FileHandle
	Cookie uint64
	Count  uint32
}

type ReadDirRes struct {
	Status uint32
	Reply  struct {
		Entries *Entry
		EOF     bool
	}
}

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

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

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

type RenameArgs struct {
	From DirOpArg
	To   DirOpArg
}

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

type ServerOptions struct {
	Name             string // Server name
	UID              uint32 // Server UID
	GID              uint32 // Server GID
	ReadOnly         bool   // Read-only mode
	Port             int    // Port to listen on (0 = random port, default NFS port is 2049)
	MountPort        int    // Port for mount daemon (0 = same as NFS port, 635 = standard mountd port)
	Hostname         string // Hostname to bind to
	Debug            bool   // Enable debug logging
	UsePortmapper    bool   // Whether to start portmapper service (requires root for port 111)
	UseRecordMarking bool   // Use RPC record marking (required for standard NFS clients)
}

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

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

type SymlinkFileSystem interface {
	Symlink(oldname, newname string) error
	Readlink(name string) (string, error)
	Lstat(name string) (os.FileInfo, error)
}

type TLSConfig struct {
	// Enabled indicates whether TLS is enabled
	Enabled bool

	// CertFile is the path to the server certificate file (PEM format)
	CertFile string

	// KeyFile is the path to the server private key file (PEM format)
	KeyFile string

	// CAFile is the path to the CA certificate file for client verification (optional)
	CAFile string

	// ClientAuth specifies the client authentication policy
	// Options: NoClientCert, RequestClientCert, RequireAnyClientCert,
	// VerifyClientCertIfGiven, RequireAndVerifyClientCert
	ClientAuth tls.ClientAuthType

	// MinVersion specifies the minimum TLS version to accept
	// Default: TLS 1.2
	MinVersion uint16

	// MaxVersion specifies the maximum TLS version to accept
	// Default: TLS 1.3
	MaxVersion uint16

	// CipherSuites is a list of enabled cipher suites
	// If empty, a secure default list will be used
	CipherSuites []uint16

	// PreferServerCipherSuites controls whether the server's cipher suite
	// preferences should be used instead of the client's
	PreferServerCipherSuites bool

	// InsecureSkipVerify controls whether the client should skip verification
	// of the server's certificate chain and host name
	// WARNING: Only for testing purposes
	InsecureSkipVerify bool
	// contains filtered or unexported fields
}

type Task struct {
	// The function to execute
	Execute func() interface{}
	// Channel to receive the result
	ResultChan chan interface{}
	// contains filtered or unexported fields
}

type TimeoutConfig struct {
	// ReadTimeout is the maximum time allowed for read operations
	// Default: 30 seconds
	ReadTimeout time.Duration

	// WriteTimeout is the maximum time allowed for write operations
	// Default: 60 seconds
	WriteTimeout time.Duration

	// LookupTimeout is the maximum time allowed for lookup operations
	// Default: 10 seconds
	LookupTimeout time.Duration

	// ReaddirTimeout is the maximum time allowed for readdir operations
	// Default: 30 seconds
	ReaddirTimeout time.Duration

	// CreateTimeout is the maximum time allowed for create operations
	// Default: 15 seconds
	CreateTimeout time.Duration

	// RemoveTimeout is the maximum time allowed for remove operations
	// Default: 15 seconds
	RemoveTimeout time.Duration

	// RenameTimeout is the maximum time allowed for rename operations
	// Default: 20 seconds
	RenameTimeout time.Duration

	// HandleTimeout is the maximum time allowed for file handle operations
	// Default: 5 seconds
	HandleTimeout time.Duration

	// DefaultTimeout is the fallback timeout for operations without a specific timeout
	// Default: 30 seconds
	DefaultTimeout time.Duration
}

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

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

type WriteArgs struct {
	Handle FileHandle
	Offset uint64
	Data   []byte
}