func (o *OortFS) Lookup(ctx context.Context, parent []byte, name string) (string, *pb.Attr, error) {
// Get the id
b, err := o.comms.ReadGroupItem(ctx, parent, []byte(name))
if store.IsNotFound(err) {
return "", &pb.Attr{}, nil
} else if err != nil {
return "", &pb.Attr{}, err
}
d := &pb.DirEntry{}
err = formic.Unmarshal(b, d)
if err != nil {
return "", &pb.Attr{}, err
}
if d.Tombstone != nil {
return "", &pb.Attr{}, nil
}
// Get the Inode entry
b, err = o.GetChunk(ctx, d.Id)
if err != nil {
return "", &pb.Attr{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return "", &pb.Attr{}, err
}
return d.Name, n.Attr, nil
}
func (o *OortFS) Rename(ctx context.Context, oldParent, newParent []byte, oldName, newName string) (*pb.RenameResponse, error) {
// Get the ID from the group list
b, err := o.comms.ReadGroupItem(ctx, oldParent, []byte(oldName))
if store.IsNotFound(err) {
return &pb.RenameResponse{}, nil
}
if err != nil {
return &pb.RenameResponse{}, err
}
d := &pb.DirEntry{}
err = formic.Unmarshal(b, d)
if err != nil {
return &pb.RenameResponse{}, err
}
// TODO: Handle orphaned data from overwrites
// Create new entry
d.Name = newName
b, err = formic.Marshal(d)
err = o.comms.WriteGroup(ctx, newParent, []byte(newName), b)
if err != nil {
return &pb.RenameResponse{}, err
}
// Delete old entry
err = o.comms.DeleteGroupItem(ctx, oldParent, []byte(oldName))
if err != nil {
// TODO: Handle errors
// If we fail here then we will have two entries
return &pb.RenameResponse{}, err
}
return &pb.RenameResponse{}, nil
}
func (o *OortFS) Update(ctx context.Context, id []byte, block, blocksize, size uint64, mtime int64) error {
b, err := o.GetChunk(ctx, id)
if err != nil {
return err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return err
}
blocks := n.Blocks
if block >= blocks {
n.Blocks = block + 1
n.LastBlock = size
n.BlockSize = blocksize
n.Attr.Size = blocksize*block + size
} else if block == (blocks - 1) {
n.LastBlock = size
n.Attr.Size = blocksize*block + size
}
if mtime > n.Attr.Mtime {
n.Attr.Mtime = mtime
}
b, err = formic.Marshal(n)
if err != nil {
return err
}
err = o.WriteChunk(ctx, id, b)
if err != nil {
return err
}
return nil
}
func (o *OortFS) ReadDirAll(ctx context.Context, id []byte) (*pb.ReadDirAllResponse, error) {
// Get the keys from the group
items, err := o.comms.ReadGroup(ctx, id)
if err != nil {
// TODO: Needs beter error handling
log.Println("Error looking up group: ", err)
return &pb.ReadDirAllResponse{}, err
}
// Iterate over each item, getting the ID then the Inode Entry
e := &pb.ReadDirAllResponse{}
dirent := &pb.DirEntry{}
for _, item := range items {
err = formic.Unmarshal(item.Value, dirent)
if err != nil {
return &pb.ReadDirAllResponse{}, err
}
if dirent.Tombstone != nil {
// Skip deleted entries
continue
}
e.DirEntries = append(e.DirEntries, &pb.DirEnt{Name: dirent.Name, Type: dirent.Type})
}
sort.Sort(ByDirent(e.DirEntries))
return e, nil
}
func (o *OortFS) Create(ctx context.Context, parent, id []byte, inode uint64, name string, attr *pb.Attr, isdir bool) (string, *pb.Attr, error) {
// Check to see if the name already exists
b, err := o.comms.ReadGroupItem(ctx, parent, []byte(name))
if err != nil && !store.IsNotFound(err) {
// TODO: Needs beter error handling
return "", &pb.Attr{}, err
}
if len(b) > 0 {
p := &pb.DirEntry{}
err = formic.Unmarshal(b, p)
if err != nil {
return "", &pb.Attr{}, err
}
// Return an error if entry already exists and is not a tombstone
if p.Tombstone == nil {
return "", &pb.Attr{}, nil
}
}
var direntType fuse.DirentType
if isdir {
direntType = fuse.DT_Dir
} else {
direntType = fuse.DT_File
}
// Add the name to the group
d := &pb.DirEntry{
Version: DirEntryVersion,
Name: name,
Id: id,
Type: uint32(direntType),
}
b, err = formic.Marshal(d)
if err != nil {
return "", &pb.Attr{}, err
}
err = o.comms.WriteGroup(ctx, parent, []byte(name), b)
if err != nil {
return "", &pb.Attr{}, err
}
// Add the inode entry
n := &pb.InodeEntry{
Version: InodeEntryVersion,
Inode: inode,
IsDir: isdir,
Attr: attr,
Blocks: 0,
}
b, err = formic.Marshal(n)
if err != nil {
return "", &pb.Attr{}, err
}
err = o.WriteChunk(ctx, id, b)
if err != nil {
return "", &pb.Attr{}, err
}
return name, attr, nil
}
func (o *OortFS) Readlink(ctx context.Context, id []byte) (*pb.ReadlinkResponse, error) {
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.ReadlinkResponse{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.ReadlinkResponse{}, err
}
return &pb.ReadlinkResponse{Target: n.Target}, nil
}
func (o *OortFS) GetAttr(ctx context.Context, id []byte) (*pb.Attr, error) {
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.Attr{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.Attr{}, err
}
return n.Attr, nil
}
func (o *OortFS) GetInode(ctx context.Context, id []byte) (*pb.InodeEntry, error) {
// Get the Inode entry
b, err := o.GetChunk(ctx, id)
if err != nil {
return nil, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return nil, err
}
return n, nil
}
func (o *OortFS) GetDirent(ctx context.Context, parent []byte, name string) (*pb.DirEntry, error) {
// Get the Dir Entry
b, err := o.comms.ReadGroupItem(ctx, parent, []byte(name))
if store.IsNotFound(err) {
return &pb.DirEntry{}, nil
} else if err != nil {
return &pb.DirEntry{}, err
}
d := &pb.DirEntry{}
err = formic.Unmarshal(b, d)
if err != nil {
return &pb.DirEntry{}, err
}
return d, nil
}
func (o *OortFS) Getxattr(ctx context.Context, id []byte, name string) (*pb.GetxattrResponse, error) {
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.GetxattrResponse{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.GetxattrResponse{}, err
}
if xattr, ok := n.Xattr[name]; ok {
return &pb.GetxattrResponse{Xattr: xattr}, nil
}
return &pb.GetxattrResponse{}, nil
}
func (o *OortFS) GetChunk(ctx context.Context, id []byte) ([]byte, error) {
b, err := o.comms.ReadValue(ctx, id)
if store.IsNotFound(err) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
fb := &pb.FileBlock{}
err = formic.Unmarshal(b, fb)
if err != nil {
return nil, err
}
// TODO: Validate checksum and handle errors
return fb.Data, nil
}
func (o *OortFS) SetAttr(ctx context.Context, id []byte, attr *pb.Attr, v uint32) (*pb.Attr, error) {
valid := fuse.SetattrValid(v)
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.Attr{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.Attr{}, err
}
if valid.Mode() {
n.Attr.Mode = attr.Mode
}
if valid.Size() {
if n.Attr.Size == 0 {
n.Blocks = 0
n.LastBlock = 0
}
n.Attr.Size = attr.Size
}
if valid.Mtime() {
n.Attr.Mtime = attr.Mtime
}
if valid.Atime() {
n.Attr.Atime = attr.Atime
}
if valid.Uid() {
n.Attr.Uid = attr.Uid
}
if valid.Gid() {
n.Attr.Gid = attr.Gid
}
b, err = formic.Marshal(n)
if err != nil {
return &pb.Attr{}, err
}
err = o.WriteChunk(ctx, id, b)
if err != nil {
return &pb.Attr{}, err
}
return n.Attr, nil
}
func (o *OortFS) Listxattr(ctx context.Context, id []byte) (*pb.ListxattrResponse, error) {
resp := &pb.ListxattrResponse{}
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.ListxattrResponse{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.ListxattrResponse{}, err
}
names := ""
for name := range n.Xattr {
names += name
names += "\x00"
}
resp.Xattr = []byte(names)
return resp, nil
}
func (o *OortFS) Remove(ctx context.Context, parent []byte, name string) (int32, error) {
// Get the ID from the group list
b, err := o.comms.ReadGroupItem(ctx, parent, []byte(name))
if store.IsNotFound(err) {
return 1, nil
} else if err != nil {
return 1, err
}
d := &pb.DirEntry{}
err = formic.Unmarshal(b, d)
if err != nil {
return 1, err
}
// TODO: More error handling needed
// TODO: Handle possible race conditions where user writes and deletes the same file over and over
// Mark the item deleted in the group
t := &pb.Tombstone{}
tsm := brimtime.TimeToUnixMicro(time.Now())
t.Dtime = tsm
t.Qtime = tsm
t.FsId = []byte("1") // TODO: Make sure this gets set when we are tracking fsids
inode, err := o.GetInode(ctx, d.Id)
if err != nil {
return 1, err
}
t.Blocks = inode.Blocks
t.Inode = inode.Inode
d.Tombstone = t
b, err = formic.Marshal(d)
if err != nil {
return 1, err
}
// NOTE: The tsm-1 is kind of a hack because the timestamp needs to be updated on this write, but if we choose tsm, once the actual delete comes through, it will not work because it is going to try to delete with a timestamp of tsm.
err = o.comms.WriteGroupTS(ctx, parent, []byte(name), b, tsm-1)
if err != nil {
return 1, err // Not really sure what should be done here to try to recover from err
}
o.deleteChan <- &DeleteItem{
parent: parent,
name: name,
}
return 0, nil
}
func (o *OortFS) Removexattr(ctx context.Context, id []byte, name string) (*pb.RemovexattrResponse, error) {
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.RemovexattrResponse{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.RemovexattrResponse{}, err
}
delete(n.Xattr, name)
b, err = formic.Marshal(n)
if err != nil {
return &pb.RemovexattrResponse{}, err
}
err = o.WriteChunk(ctx, id, b)
if err != nil {
return &pb.RemovexattrResponse{}, err
}
return &pb.RemovexattrResponse{}, nil
}
func (o *OortFS) Setxattr(ctx context.Context, id []byte, name string, value []byte) (*pb.SetxattrResponse, error) {
b, err := o.GetChunk(ctx, id)
if err != nil {
return &pb.SetxattrResponse{}, err
}
n := &pb.InodeEntry{}
err = formic.Unmarshal(b, n)
if err != nil {
return &pb.SetxattrResponse{}, err
}
if n.Xattr == nil {
n.Xattr = make(map[string][]byte)
}
n.Xattr[name] = value
b, err = formic.Marshal(n)
if err != nil {
return &pb.SetxattrResponse{}, err
}
err = o.WriteChunk(ctx, id, b)
if err != nil {
return &pb.SetxattrResponse{}, err
}
return &pb.SetxattrResponse{}, nil
}