Initial commit
This commit is contained in:
Mikaël Cluseau
52
log/compress.go
Normal file
52
log/compress.go
Normal file
@ -0,0 +1,52 @@
|
||||
package log
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
"github.com/ulikunitz/xz"
|
||||
)
|
||||
|
||||
func compress(path string) {
|
||||
in, err := os.Open(path)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "compress %s: failed to open: %v", path, err)
|
||||
return
|
||||
}
|
||||
|
||||
defer in.Close()
|
||||
|
||||
outPath := filepath.Join(filepath.Dir(path), "archives", filepath.Base(path)+".xz")
|
||||
|
||||
os.MkdirAll(filepath.Dir(outPath), 0700)
|
||||
|
||||
out, err := os.Create(outPath)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "compress %s: failed to create target: %v", path, err)
|
||||
return
|
||||
}
|
||||
|
||||
defer out.Close()
|
||||
|
||||
w, err := xz.NewWriter(out)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "compress %s: failed to create writer: %v", path, err)
|
||||
return
|
||||
}
|
||||
|
||||
if _, err := io.Copy(w, in); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "compress %s: write failed: %v", path, err)
|
||||
return
|
||||
}
|
||||
|
||||
if err := w.Close(); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "compress %s: close failed: %v", path, err)
|
||||
return
|
||||
}
|
||||
|
||||
if err := os.Remove(path); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "compress %s: failed to remove source: %v", path, err)
|
||||
}
|
||||
}
|
||||
119
log/entry.go
Normal file
119
log/entry.go
Normal file
@ -0,0 +1,119 @@
|
||||
package log
|
||||
|
||||
import (
|
||||
"encoding/base32"
|
||||
"fmt"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Entry struct {
|
||||
Time time.Time
|
||||
Taint Taint
|
||||
Data []byte
|
||||
}
|
||||
|
||||
// WriteTo writes this log entry to w.
|
||||
// Automatically appends a new line if it's not already present to
|
||||
// get an easy to read log.
|
||||
func (e Entry) WriteTo(w io.Writer) (n int64, err error) {
|
||||
l := len(e.Data)
|
||||
t := e.Time.UnixNano()
|
||||
|
||||
flags := byte(0)
|
||||
appendNL := e.Data[len(e.Data)-1] != '\n'
|
||||
|
||||
if appendNL {
|
||||
flags |= AppendNL
|
||||
}
|
||||
|
||||
b := []byte{
|
||||
flags,
|
||||
byte(e.Taint),
|
||||
byte(l >> 16 & 0xff),
|
||||
byte(l >> 8 & 0xff),
|
||||
byte(l >> 0 & 0xff),
|
||||
byte(t >> 56 & 0xff),
|
||||
byte(t >> 48 & 0xff),
|
||||
byte(t >> 40 & 0xff),
|
||||
byte(t >> 32 & 0xff),
|
||||
byte(t >> 24 & 0xff),
|
||||
byte(t >> 16 & 0xff),
|
||||
byte(t >> 8 & 0xff),
|
||||
byte(t >> 0 & 0xff),
|
||||
}
|
||||
|
||||
// the binary part is b32 encoded. Obscure but still readable in text mode.
|
||||
enc := base32.StdEncoding
|
||||
|
||||
headerLen := enc.EncodedLen(len(b))
|
||||
baLen := headerLen + len(e.Data)
|
||||
if appendNL {
|
||||
baLen++
|
||||
}
|
||||
ba := make([]byte, baLen)
|
||||
enc.Encode(ba, b)
|
||||
|
||||
copy(ba[headerLen:], e.Data)
|
||||
|
||||
if appendNL {
|
||||
ba[baLen-1] = '\n'
|
||||
}
|
||||
|
||||
nw, err := w.Write(ba)
|
||||
return int64(nw), err
|
||||
}
|
||||
|
||||
// ReadFrom reads the next entry from r, updating this entry.
|
||||
func (e *Entry) ReadFrom(r io.Reader) (n int64, err error) {
|
||||
enc := base32.StdEncoding
|
||||
|
||||
const L = 1 + 1 + 3 + 8
|
||||
b := make([]byte, L)
|
||||
ba := make([]byte, enc.EncodedLen(L))
|
||||
|
||||
nr, err := r.Read(ba)
|
||||
if err != nil {
|
||||
return int64(nr), err
|
||||
}
|
||||
fmt.Println(string(ba))
|
||||
|
||||
enc.Decode(b, ba)
|
||||
fmt.Println(b)
|
||||
|
||||
p := 0
|
||||
flags := b[p]
|
||||
p++
|
||||
|
||||
e.Taint = Taint(b[p])
|
||||
p++
|
||||
|
||||
l := int32(0)
|
||||
for i := 0; i < 3; i++ {
|
||||
l = l<<8 | int32(b[p])
|
||||
p++
|
||||
}
|
||||
|
||||
readLen := l
|
||||
if flags|AppendNL != 0 {
|
||||
readLen++
|
||||
}
|
||||
|
||||
t := int64(0)
|
||||
for i := 0; i < 8; i++ {
|
||||
t = t<<8 | int64(b[p])
|
||||
p++
|
||||
}
|
||||
e.Time = time.Unix(0, t)
|
||||
|
||||
data := make([]byte, readLen)
|
||||
m, err := r.Read(data)
|
||||
n += int64(m)
|
||||
if err != nil {
|
||||
return n, err
|
||||
}
|
||||
|
||||
e.Data = data[:l]
|
||||
|
||||
return n, nil
|
||||
}
|
||||
38
log/entry_test.go
Normal file
38
log/entry_test.go
Normal file
@ -0,0 +1,38 @@
|
||||
package log
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestEncode(t *testing.T) {
|
||||
l1 := Entry{time.Now(), Normal, []byte("test entry")}
|
||||
l2 := Entry{}
|
||||
|
||||
buf := &bytes.Buffer{}
|
||||
l1.WriteTo(buf)
|
||||
|
||||
t.Log(buf.String())
|
||||
|
||||
_, err := l2.ReadFrom(buf)
|
||||
if err != nil {
|
||||
t.Error("read error: ", err)
|
||||
}
|
||||
|
||||
if l1.Taint != l2.Taint {
|
||||
t.Errorf("wrong taint: %v != %v", l1.Taint, l2.Taint)
|
||||
}
|
||||
|
||||
if l1.Time.UnixNano() != l2.Time.UnixNano() {
|
||||
t.Errorf("wrong time: %v != %v", l1.Time, l2.Time)
|
||||
}
|
||||
|
||||
if !bytes.Equal(l1.Data, l2.Data) {
|
||||
t.Errorf("wrong data: %q != %q", string(l1.Data), string(l2.Data))
|
||||
}
|
||||
|
||||
if l := len(buf.Bytes()); l > 0 {
|
||||
t.Errorf("%d bytes not read", l)
|
||||
}
|
||||
}
|
||||
244
log/log.go
Normal file
244
log/log.go
Normal file
@ -0,0 +1,244 @@
|
||||
package log
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"novit.nc/direktil/src/pkg/color"
|
||||
)
|
||||
|
||||
const (
|
||||
// AppendNL indicates that a forced '\n' is added.
|
||||
AppendNL byte = 1
|
||||
)
|
||||
|
||||
var (
|
||||
logs = map[string]*Log{}
|
||||
mutex = sync.Mutex{}
|
||||
|
||||
logOutputEnabled = false
|
||||
)
|
||||
|
||||
// Log is a log target
|
||||
type Log struct {
|
||||
name string
|
||||
|
||||
l sync.Mutex
|
||||
writeToFile bool
|
||||
|
||||
console io.Writer
|
||||
pending []Entry
|
||||
out *os.File
|
||||
outPath string
|
||||
}
|
||||
|
||||
func Get(name string) *Log {
|
||||
mutex.Lock()
|
||||
defer mutex.Unlock()
|
||||
|
||||
if log, ok := logs[name]; ok {
|
||||
return log
|
||||
}
|
||||
|
||||
log := &Log{
|
||||
name: name,
|
||||
pending: make([]Entry, 0),
|
||||
}
|
||||
|
||||
if logOutputEnabled {
|
||||
log.enableFileOutput()
|
||||
}
|
||||
|
||||
logs[name] = log
|
||||
|
||||
return log
|
||||
}
|
||||
|
||||
// EnableFiles flushes current logs to files, and enables output to files.
|
||||
func EnableFiles() {
|
||||
mutex.Lock()
|
||||
defer mutex.Unlock()
|
||||
|
||||
if logOutputEnabled {
|
||||
return
|
||||
}
|
||||
|
||||
for _, log := range logs {
|
||||
// we'll let the kernel optimize, just do it all parallel
|
||||
go log.enableFileOutput()
|
||||
}
|
||||
|
||||
logOutputEnabled = true
|
||||
}
|
||||
|
||||
// DisableFiles flushes and closes current logs files, and disables output to files.
|
||||
func DisableFiles() {
|
||||
mutex.Lock()
|
||||
defer mutex.Unlock()
|
||||
|
||||
if !logOutputEnabled {
|
||||
return
|
||||
}
|
||||
|
||||
for _, log := range logs {
|
||||
// we'll let the kernel optimize, just do it all parallel
|
||||
go log.disableFileOutput()
|
||||
}
|
||||
|
||||
logOutputEnabled = false
|
||||
}
|
||||
|
||||
func (l *Log) enableFileOutput() {
|
||||
l.l.Lock()
|
||||
defer l.l.Unlock()
|
||||
|
||||
for _, e := range l.pending {
|
||||
if err := l.writeEntry(e); err != nil {
|
||||
l.emergencyLog(e, err)
|
||||
}
|
||||
}
|
||||
l.writeToFile = true
|
||||
}
|
||||
|
||||
func (l *Log) disableFileOutput() {
|
||||
l.l.Lock()
|
||||
defer l.l.Unlock()
|
||||
|
||||
if l.out != nil {
|
||||
l.out.Close()
|
||||
}
|
||||
|
||||
l.writeToFile = false
|
||||
}
|
||||
|
||||
func (l *Log) SetConsole(console io.Writer) {
|
||||
l.console = console
|
||||
}
|
||||
|
||||
// StreamLines will copy the input line by line as log entries.
|
||||
func (l *Log) StreamLines(r io.Reader) {
|
||||
in := bufio.NewReader(r)
|
||||
for {
|
||||
line, err := in.ReadBytes('\n')
|
||||
if err != nil {
|
||||
if err != io.EOF {
|
||||
fmt.Fprintf(os.Stderr, "log %s: read lines failed: %v\n", l.name, err)
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
return
|
||||
}
|
||||
l.Write(line)
|
||||
}
|
||||
}
|
||||
|
||||
// Print to this log.
|
||||
func (l *Log) Print(v ...interface{}) {
|
||||
fmt.Fprint(l, v...)
|
||||
}
|
||||
|
||||
// Printf to this log.
|
||||
func (l *Log) Printf(pattern string, v ...interface{}) {
|
||||
fmt.Fprintf(l, pattern, v...)
|
||||
}
|
||||
|
||||
// Taint is Print to this log with a taint.
|
||||
func (l *Log) Taint(taint Taint, v ...interface{}) {
|
||||
l.append(taint, []byte(fmt.Sprint(v...)))
|
||||
}
|
||||
|
||||
// Taintf is Printf to this log with a taint.
|
||||
func (l *Log) Taintf(taint Taint, pattern string, v ...interface{}) {
|
||||
l.append(taint, []byte(fmt.Sprintf(pattern, v...)))
|
||||
}
|
||||
|
||||
func (l *Log) append(taint Taint, data []byte) {
|
||||
// we serialize writes
|
||||
l.l.Lock()
|
||||
defer l.l.Unlock()
|
||||
|
||||
e := Entry{
|
||||
Time: time.Now(),
|
||||
Taint: taint,
|
||||
Data: data,
|
||||
}
|
||||
|
||||
console := l.console
|
||||
if console != nil {
|
||||
buf := &bytes.Buffer{}
|
||||
buf.WriteString(string(color.DarkGreen))
|
||||
buf.WriteString(e.Time.Format("2006/01/02 15:04:05.000 "))
|
||||
buf.WriteString(string(color.Reset))
|
||||
buf.WriteString(string(e.Taint.Color()))
|
||||
buf.Write(data)
|
||||
if data[len(data)-1] != '\n' {
|
||||
buf.Write([]byte{'\n'})
|
||||
}
|
||||
buf.WriteString(string(color.Reset))
|
||||
|
||||
buf.WriteTo(console)
|
||||
}
|
||||
|
||||
if !l.writeToFile {
|
||||
l.pending = append(l.pending, e)
|
||||
// TODO if len(pending) > maxPending { pending = pending[len(pending)-underMaxPending:] }
|
||||
// or use a ring
|
||||
return
|
||||
}
|
||||
|
||||
if err := l.writeEntry(e); err != nil {
|
||||
l.emergencyLog(e, err)
|
||||
}
|
||||
}
|
||||
|
||||
func (l *Log) emergencyLog(entry Entry, err error) {
|
||||
fmt.Fprintf(os.Stderr, "log %s: failed to write entry: %v\n -> lost entry: ", l.name, err)
|
||||
entry.WriteTo(os.Stderr)
|
||||
}
|
||||
|
||||
// Write is part of the io.Writer interface.
|
||||
func (l *Log) Write(b []byte) (n int, err error) {
|
||||
l.append(Normal, b)
|
||||
return len(b), nil
|
||||
}
|
||||
|
||||
func (l *Log) writeEntry(e Entry) (err error) {
|
||||
path := fmt.Sprintf("/var/log/%s.%s.log",
|
||||
l.name, e.Time.Truncate(time.Hour).Format(time.RFC3339))
|
||||
|
||||
currentPath := fmt.Sprintf("/var/log/%s.log", l.name)
|
||||
|
||||
if l.outPath != path {
|
||||
if l.out != nil {
|
||||
if err := l.out.Close(); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "log %s: failed to close output: %v\n", l.name, err)
|
||||
}
|
||||
os.Remove(currentPath)
|
||||
go compress(l.outPath)
|
||||
}
|
||||
l.out = nil
|
||||
l.outPath = ""
|
||||
}
|
||||
|
||||
if l.out == nil {
|
||||
l.out, err = os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0640)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
l.outPath = path
|
||||
|
||||
os.Remove(currentPath)
|
||||
if err := os.Symlink(path, currentPath); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "failed to symlink %s.log: %v\n", l.name, err)
|
||||
}
|
||||
}
|
||||
|
||||
_, err = e.WriteTo(l.out)
|
||||
|
||||
return
|
||||
}
|
||||
33
log/taint.go
Normal file
33
log/taint.go
Normal file
@ -0,0 +1,33 @@
|
||||
package log
|
||||
|
||||
import (
|
||||
"novit.nc/direktil/src/pkg/color"
|
||||
)
|
||||
|
||||
const (
|
||||
Normal Taint = iota
|
||||
Info
|
||||
Warning
|
||||
Error
|
||||
Fatal
|
||||
OK
|
||||
)
|
||||
|
||||
type Taint byte
|
||||
|
||||
func (t Taint) Color() color.Color {
|
||||
switch t {
|
||||
case Info:
|
||||
return color.Blue
|
||||
case Warning:
|
||||
return color.Yellow
|
||||
case Error:
|
||||
return color.Red
|
||||
case Fatal:
|
||||
return color.Magenta
|
||||
case OK:
|
||||
return color.Green
|
||||
default:
|
||||
return color.None
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user