861c88b8e8
- pkg/api/provider.go: remove banned os/syscall imports; delegate to
new process.KillPID and process.IsPIDAlive exported helpers
- service.go: rename `sr` → `startResult`; add KillPID/IsPIDAlive exports
- runner.go: rename `aggResult` → `aggregate` in all three RunXxx methods;
add usage-example comments on all exported functions
- process.go: replace prose doc-comments with usage-example comments
- buffer.go, registry.go, health.go: replace prose comments with examples
- buffer_test.go: rename TestRingBuffer_Basics_Good → TestBuffer_{Write,String,Reset}_{Good,Bad,Ugly}
- All test files: add missing _Bad and _Ugly variants for all functions
(daemon, health, pidfile, registry, runner, process, program, exec, pkg/api)
Co-Authored-By: Virgil <virgil@lethean.io>
112 lines
2.2 KiB
Go
112 lines
2.2 KiB
Go
package process
|
|
|
|
import "sync"
|
|
|
|
// RingBuffer is a fixed-size circular buffer that overwrites old data.
|
|
// Thread-safe for concurrent reads and writes.
|
|
//
|
|
// rb := process.NewRingBuffer(1024)
|
|
type RingBuffer struct {
|
|
data []byte
|
|
size int
|
|
start int
|
|
end int
|
|
full bool
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
// NewRingBuffer creates a ring buffer with the given capacity.
|
|
//
|
|
// rb := process.NewRingBuffer(256)
|
|
func NewRingBuffer(size int) *RingBuffer {
|
|
return &RingBuffer{
|
|
data: make([]byte, size),
|
|
size: size,
|
|
}
|
|
}
|
|
|
|
// _, _ = rb.Write([]byte("output line\n"))
|
|
func (rb *RingBuffer) Write(p []byte) (n int, err error) {
|
|
rb.mu.Lock()
|
|
defer rb.mu.Unlock()
|
|
|
|
for _, b := range p {
|
|
rb.data[rb.end] = b
|
|
rb.end = (rb.end + 1) % rb.size
|
|
if rb.full {
|
|
rb.start = (rb.start + 1) % rb.size
|
|
}
|
|
if rb.end == rb.start {
|
|
rb.full = true
|
|
}
|
|
}
|
|
return len(p), nil
|
|
}
|
|
|
|
// output := rb.String() // returns all buffered output as a string
|
|
func (rb *RingBuffer) String() string {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
if !rb.full && rb.start == rb.end {
|
|
return ""
|
|
}
|
|
|
|
if rb.full {
|
|
result := make([]byte, rb.size)
|
|
copy(result, rb.data[rb.start:])
|
|
copy(result[rb.size-rb.start:], rb.data[:rb.end])
|
|
return string(result)
|
|
}
|
|
|
|
return string(rb.data[rb.start:rb.end])
|
|
}
|
|
|
|
// data := rb.Bytes() // returns nil if empty
|
|
func (rb *RingBuffer) Bytes() []byte {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
if !rb.full && rb.start == rb.end {
|
|
return nil
|
|
}
|
|
|
|
if rb.full {
|
|
result := make([]byte, rb.size)
|
|
copy(result, rb.data[rb.start:])
|
|
copy(result[rb.size-rb.start:], rb.data[:rb.end])
|
|
return result
|
|
}
|
|
|
|
result := make([]byte, rb.end-rb.start)
|
|
copy(result, rb.data[rb.start:rb.end])
|
|
return result
|
|
}
|
|
|
|
// byteCount := rb.Len() // 0 when empty, Cap() when full
|
|
func (rb *RingBuffer) Len() int {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
if rb.full {
|
|
return rb.size
|
|
}
|
|
if rb.end >= rb.start {
|
|
return rb.end - rb.start
|
|
}
|
|
return rb.size - rb.start + rb.end
|
|
}
|
|
|
|
// capacity := rb.Cap() // fixed at construction time
|
|
func (rb *RingBuffer) Cap() int {
|
|
return rb.size
|
|
}
|
|
|
|
// rb.Reset() // discard all buffered output
|
|
func (rb *RingBuffer) Reset() {
|
|
rb.mu.Lock()
|
|
defer rb.mu.Unlock()
|
|
rb.start = 0
|
|
rb.end = 0
|
|
rb.full = false
|
|
}
|