153 lines
2.9 KiB
Go
153 lines
2.9 KiB
Go
package storage
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
|
|
"git.nicholasnovak.io/nnovak/spatial-db/world"
|
|
)
|
|
|
|
// A `UnityFile` is a collection of chunks, stored as a single file on disk
|
|
//
|
|
// This is done because with worlds that span millions of chunks, the speed to
|
|
// access individual files slows down
|
|
type UnityFile struct {
|
|
fd *os.File
|
|
fileSize int
|
|
// metadata maps the position of a chunk to its start index within the file
|
|
metadata map[world.ChunkPos]fileMetadata
|
|
}
|
|
|
|
type fileMetadata struct {
|
|
StartOffset int `json:"start_offset"`
|
|
FileSize int `json:"file_size"`
|
|
}
|
|
|
|
func CreateUnityFile(fileName string) (UnityFile, error) {
|
|
var u UnityFile
|
|
|
|
f, err := os.Create(fileName)
|
|
if err != nil {
|
|
return u, err
|
|
}
|
|
|
|
u.fd = f
|
|
u.metadata = make(map[world.ChunkPos]fileMetadata)
|
|
|
|
return u, nil
|
|
}
|
|
|
|
func OpenUnityFile(fileName, metadataName string) (UnityFile, error) {
|
|
var u UnityFile
|
|
|
|
// Read the file
|
|
f, err := os.Open(fileName)
|
|
if err != nil {
|
|
return u, err
|
|
}
|
|
u.fd = f
|
|
|
|
if err := u.ReadMetadataFile(metadataName); err != nil {
|
|
return u, err
|
|
}
|
|
|
|
return u, nil
|
|
}
|
|
|
|
func (u UnityFile) Size() int {
|
|
return u.fileSize
|
|
}
|
|
|
|
func (u *UnityFile) WriteChunk(data world.ChunkData) error {
|
|
var encoded bytes.Buffer
|
|
|
|
// Encode the chunk first
|
|
if err := json.NewEncoder(&encoded).Encode(data); err != nil {
|
|
return err
|
|
}
|
|
|
|
encodedSize := encoded.Len()
|
|
|
|
// Go to the end of the file
|
|
u.fd.Seek(int64(u.fileSize), io.SeekStart)
|
|
// Write the encoded contents to the file
|
|
if _, err := u.fd.Write(encoded.Bytes()); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Update the metadata with the new file
|
|
u.metadata[data.Pos] = fileMetadata{
|
|
StartOffset: u.fileSize,
|
|
FileSize: encodedSize,
|
|
}
|
|
u.fileSize += encodedSize
|
|
|
|
return nil
|
|
}
|
|
|
|
func (u UnityFile) WriteMetadataFile(fileName string) error {
|
|
fd, err := os.OpenFile(fileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fd.Close()
|
|
|
|
if err := json.NewEncoder(fd).Encode(&u.metadata); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (u *UnityFile) ReadMetadataFile(fileName string) error {
|
|
fd, err := os.Open(fileName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := json.NewDecoder(fd).Decode(&u.metadata); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (u UnityFile) ReadChunk(pos world.ChunkPos) (world.ChunkData, error) {
|
|
m, contains := u.metadata[pos]
|
|
if !contains {
|
|
return world.ChunkData{}, fs.ErrNotExist
|
|
}
|
|
|
|
u.fd.Seek(int64(m.StartOffset), io.SeekStart)
|
|
|
|
fileReader := io.LimitReader(u.fd, int64(m.FileSize))
|
|
|
|
var data world.ChunkData
|
|
if err := json.NewDecoder(fileReader).Decode(&data); err != nil {
|
|
return world.ChunkData{}, err
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func (u UnityFile) ReadAllChunks() ([]world.ChunkData, error) {
|
|
chunks := []world.ChunkData{}
|
|
|
|
for pos := range u.metadata {
|
|
chunk, err := u.ReadChunk(pos)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
chunks = append(chunks, chunk)
|
|
}
|
|
|
|
return chunks, nil
|
|
}
|
|
|
|
func (u *UnityFile) Close() error {
|
|
return u.fd.Close()
|
|
}
|