Ein Anderssono
109 lines
2.3 KiB
Go
109 lines
2.3 KiB
Go
package manifest
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
type Format string
|
|
|
|
const (
|
|
FormatJSONL Format = "jsonl"
|
|
FormatSQLite Format = "sqlite"
|
|
)
|
|
|
|
func Open(dir string, format Format) (Manifest, error) {
|
|
jsonlPath := JSONLPath(dir)
|
|
sqlitePath := SQLitePath(dir)
|
|
jsonlExists := FileExists(jsonlPath)
|
|
sqliteExists := FileExists(sqlitePath)
|
|
|
|
switch {
|
|
case format == FormatJSONL && jsonlExists:
|
|
return LoadJSONL(dir), nil
|
|
case format == FormatSQLite && sqliteExists:
|
|
return LoadSQLite(dir)
|
|
case format == FormatJSONL && sqliteExists:
|
|
return ConvertFromSQLite(dir)
|
|
case format == FormatSQLite && jsonlExists:
|
|
return ConvertFromJSONL(dir)
|
|
default:
|
|
if format == FormatJSONL {
|
|
return LoadJSONL(dir), nil
|
|
}
|
|
return LoadSQLite(dir)
|
|
}
|
|
}
|
|
|
|
func ConvertFromJSONL(dir string) (Manifest, error) {
|
|
src := LoadJSONL(dir)
|
|
if err := src.OpenAppend(); err != nil {
|
|
return nil, fmt.Errorf("open jsonl for read: %w", err)
|
|
}
|
|
defer src.Close()
|
|
|
|
dst, _ := LoadSQLite(dir)
|
|
if err := dst.OpenAppend(); err != nil {
|
|
return nil, fmt.Errorf("open sqlite for write: %w", err)
|
|
}
|
|
|
|
for id, e := range src.Entries() {
|
|
e.ID = id
|
|
dst.AddEntry(e)
|
|
}
|
|
|
|
os.Remove(JSONLPath(dir))
|
|
return dst, nil
|
|
}
|
|
|
|
func ConvertFromSQLite(dir string) (Manifest, error) {
|
|
src, _ := LoadSQLite(dir)
|
|
if err := src.OpenAppend(); err != nil {
|
|
return nil, fmt.Errorf("open sqlite for read: %w", err)
|
|
}
|
|
defer src.Close()
|
|
|
|
dst := LoadJSONL(dir)
|
|
if err := dst.OpenAppend(); err != nil {
|
|
return nil, fmt.Errorf("open jsonl for write: %w", err)
|
|
}
|
|
|
|
for id, e := range src.Entries() {
|
|
e.ID = id
|
|
dst.AddEntry(e)
|
|
}
|
|
if err := dst.Save(); err != nil {
|
|
return nil, fmt.Errorf("save jsonl: %w", err)
|
|
}
|
|
|
|
os.Remove(SQLitePath(dir))
|
|
return dst, nil
|
|
}
|
|
|
|
func FileExists(path string) bool {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return !info.IsDir()
|
|
}
|
|
|
|
func ParseFormat(s string) (Format, error) {
|
|
switch strings.ToLower(s) {
|
|
case "jsonl", "json":
|
|
return FormatJSONL, nil
|
|
case "sqlite", "db", "sqlite3":
|
|
return FormatSQLite, nil
|
|
default:
|
|
return "", fmt.Errorf("unknown manifest format %q (use jsonl or sqlite)", s)
|
|
}
|
|
}
|
|
|
|
func OpenLogWriter(m Manifest, dir string) (LogWriter, error) {
|
|
if sm, ok := m.(*sqliteManifest); ok && sm.DB() != nil {
|
|
return NewSQLiteLogWriter(sm.DB())
|
|
}
|
|
return NewFileLogWriter(LogPath(dir))
|
|
}
|