// RevokeAddrFS ...
func (s *FileSystemAPIServer) RevokeAddrFS(ctx context.Context, r *pb.RevokeAddrFSRequest) (*pb.RevokeAddrFSResponse, error) {
var err error
var acctID string
var value []byte
var fsRef FileSysRef
srcAddr := ""
// Get incomming ip
pr, ok := peer.FromContext(ctx)
if ok {
srcAddr = pr.Addr.String()
}
// Validate Token
acctID, err = s.validateToken(r.Token)
if err != nil {
log.Printf("%s REVOKE FAILED %s\n", srcAddr, "PermissionDenied")
return nil, errf(codes.PermissionDenied, "%v", "Invalid Token")
}
// Validate Token/Account owns this file system
// Read FileSysRef entry to determine if it exists
pKey := fmt.Sprintf("/fs")
pKeyA, pKeyB := murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB := murmur3.Sum128([]byte(r.FSid))
_, value, err = s.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
log.Printf("%s REVOKE FAILED %s NOTFOUND", srcAddr, r.FSid)
return nil, errf(codes.NotFound, "%v", "Not Found")
}
if err != nil {
log.Printf("%s REVOKE FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
err = json.Unmarshal(value, &fsRef)
if err != nil {
log.Printf("%s REVOKE FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
if fsRef.AcctID != acctID {
log.Printf("$s REVOKE FAILED %v ACCOUNT MISMATCH", r.FSid)
return nil, errf(codes.FailedPrecondition, "%v", "Account Mismatch")
}
// REVOKE an file system entry for the addr
// delete /fs/FSID/addr addr AddrRef
pKey = fmt.Sprintf("/fs/%s/addr", r.FSid)
pKeyA, pKeyB = murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB = murmur3.Sum128([]byte(r.Addr))
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
_, err = s.gstore.Delete(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, timestampMicro)
if store.IsNotFound(err) {
log.Printf("%s REVOKE FAILED %s %s\n", srcAddr, r.FSid, r.Addr)
return nil, errf(codes.NotFound, "%v", "Not Found")
}
// return Addr was revoked
// Log Operation
log.Printf("%s REVOKE SUCCESS %s %s\n", srcAddr, r.FSid, r.Addr)
return &pb.RevokeAddrFSResponse{Data: r.FSid}, nil
}
func (d *Deletinator) run() {
// TODO: Parallelize this thing?
for {
todelete := <-d.in
log.Println("Deleting: ", todelete)
// TODO: Need better context
p := &peer.Peer{
Addr: localAddr{},
}
ctx := peer.NewContext(context.Background(), p)
// Get the dir entry info
dirent, err := d.fs.GetDirent(ctx, todelete.parent, todelete.name)
if store.IsNotFound(err) {
// NOTE: If it isn't found then it is likely deleted.
// Do we need to do more to ensure this?
// Skip for now
continue
}
if err != nil {
// TODO Better error handling?
// re-q the id, to try again later
log.Print("Delete error getting dirent: ", err)
d.in <- todelete
continue
}
ts := dirent.Tombstone
deleted := uint64(0)
for b := uint64(0); b < ts.Blocks; b++ {
log.Println(" Deleting block: ", b)
// Delete each block
id := GetID(ts.FsId, ts.Inode, b+1)
err := d.fs.DeleteChunk(ctx, id, ts.Dtime)
if err != nil && !store.IsNotFound(err) && err != ErrStoreHasNewerValue {
continue
}
deleted++
}
if deleted == ts.Blocks {
// Everything is deleted so delete the entry
log.Println(" Deleting Inode")
err := d.fs.DeleteChunk(ctx, GetID(ts.FsId, ts.Inode, 0), ts.Dtime)
if err != nil && !store.IsNotFound(err) && err != ErrStoreHasNewerValue {
// Couldn't delete the inode entry so try again later
d.in <- todelete
continue
}
log.Println(" Deleting Listing")
err = d.fs.DeleteListing(ctx, todelete.parent, todelete.name, ts.Dtime)
if err != nil && !store.IsNotFound(err) && err != ErrStoreHasNewerValue {
log.Println(" Err: ", err)
// TODO: Better error handling
// Ignore for now to be picked up later?
}
} else {
// If all artifacts are not deleted requeue for later
d.in <- todelete
}
}
}
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 = proto.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 = proto.Unmarshal(b, n)
if err != nil {
return "", &pb.Attr{}, err
}
return d.Name, n.Attr, nil
}
// RevokeAddrFS ...
func (s *FileSystemAPIServer) RevokeAddrFS(ctx context.Context, r *pb.RevokeAddrFSRequest) (*pb.RevokeAddrFSResponse, error) {
var err error
srcAddr := ""
// Get incomming ip
pr, ok := peer.FromContext(ctx)
if ok {
srcAddr = pr.Addr.String()
}
// Validate Token
_, err = s.validateToken(r.Token)
if err != nil {
log.Printf("%s REVOKE FAILED %s\n", srcAddr, "PermissionDenied")
return nil, errf(codes.PermissionDenied, "%v", "Invalid Token")
}
// REVOKE an file system entry for the addr
// delete /fs/FSID/addr addr AddrRef
pKey := fmt.Sprintf("/fs/%s/addr", r.FSid)
pKeyA, pKeyB := murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB := murmur3.Sum128([]byte(r.Addr))
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
_, err = s.gstore.Delete(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, timestampMicro)
if store.IsNotFound(err) {
log.Printf("%s REVOKE FAILED %s %s\n", srcAddr, r.FSid, r.Addr)
return nil, errf(codes.NotFound, "%v", "Not Found")
}
// return Addr was revoked
// Log Operation
log.Printf("%s REVOKE SUCCESS %s %s\n", srcAddr, r.FSid, r.Addr)
return &pb.RevokeAddrFSResponse{Data: r.FSid}, 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 = proto.Unmarshal(b, d)
if err != nil {
return &pb.RenameResponse{}, err
}
// TODO: Handle orphaned data from overwrites
// Create new entry
d.Name = newName
b, err = proto.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 TranslateError(err error) string {
if store.IsDisabled(err) {
return "::github.com/gholt/store/ErrDisabled::"
} else if store.IsNotFound(err) {
return "::github.com/gholt/store/ErrNotFound::"
}
return err.Error()
}
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
}
// validateToken ...
func (s *FileSystemAPIServer) validateToken(t string) (string, error) {
var tData TokenRef
var aData AcctPayLoad
var tDataByte []byte
var aDataByte []byte
var err error
// Read Token
pKeyA, pKeyB := murmur3.Sum128([]byte("/token"))
cKeyA, cKeyB := murmur3.Sum128([]byte(t))
_, tDataByte, err = s.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
return "", errors.New("Not Found")
}
err = json.Unmarshal(tDataByte, &tData)
if err != nil {
log.Printf("TOKEN FAILED %v\n", err)
return "", err
}
// Read Account
pKeyA, pKeyB = murmur3.Sum128([]byte("/acct"))
cKeyA, cKeyB = murmur3.Sum128([]byte(tData.AcctID))
_, aDataByte, err = s.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
return "", errors.New("Not Found")
}
err = json.Unmarshal(aDataByte, &aData)
if err != nil {
log.Printf("TOKEN FAILED %v\n", err)
return "", err
}
if tData.TokenID != aData.Token {
// Log Failed Operation
log.Printf("TOKEN FAIL %s\n", t)
return "", errors.New("Invalid Token")
}
// Return Account UUID
// Log Operation
log.Printf("TOKEN SUCCESS %s\n", tData.AcctID)
return tData.AcctID, nil
}
func (o *OortFS) Create(ctx context.Context, parent, id []byte, inode uint64, name string, attr *pb.Attr, isdir bool) (string, *pb.Attr, error) {
v, err := o.validateIP(ctx)
if err != nil {
return "", nil, err
}
if !v {
return "", nil, errors.New("Unknown or unauthorized FS use")
}
// 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 {
return "", &pb.Attr{}, nil
}
p := &pb.DirEntry{}
err = proto.Unmarshal(b, p)
if err != nil {
return "", &pb.Attr{}, err
}
// Add the name to the group
d := &pb.DirEntry{
Version: DirEntryVersion,
Name: name,
Id: id,
}
b, err = proto.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 = proto.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
}
// ShowFS ...
func (s *FileSystemAPIServer) ShowFS(ctx context.Context, r *fb.ShowFSRequest) (*fb.ShowFSResponse, error) {
var status string
var acctData AcctPayLoad
var fsData FileSysPayLoad
var fsDataB []byte
var err error
// Get incomming ip
pr, ok := peer.FromContext(ctx)
if ok {
fmt.Println(pr.Addr)
}
// getAcct data
acctData, err = s.getAcct("/acct", r.Acctnum)
if err != nil {
log.Printf("Error %v on lookup for account %s", err, r.Acctnum)
return nil, err
}
// validate token
if acctData.Token != r.Token {
return nil, errf(codes.PermissionDenied, "%s", "Invalid Token")
}
pKey := fmt.Sprintf("/acct/%s/fs", r.Acctnum)
pKeyA, pKeyB := murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB := murmur3.Sum128([]byte(r.FSid))
_, fsDataB, err = s.fsws.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
return nil, errf(codes.NotFound, "%v", "File System Not Found")
}
if err != nil {
return nil, errf(codes.Internal, "%s", err)
}
err = json.Unmarshal(fsDataB, &fsData)
if err != nil {
return nil, errf(codes.Internal, "%s", err)
}
// Get list of Addr
fsData.Addr, err = s.addrList(fsData.ID)
if err != nil {
return nil, errf(codes.Internal, "%s", err)
}
fsDataB, err = json.Marshal(&fsData)
if err != nil {
return nil, errf(codes.Internal, "%s", err)
}
// Prep things to return
status = "OK"
return &fb.ShowFSResponse{Payload: string(fsDataB), Status: status}, nil
}
// lookupAccount ...
func (fsws *FileSystemWS) getGStore(g string, m string) (string, error) {
log.Println("Starting a Read from the Group Store")
keyA, keyB := murmur3.Sum128([]byte(g))
childKeyA, childKeyB := murmur3.Sum128([]byte(m))
_, value, err := fsws.gstore.Read(context.Background(), keyA, keyB, childKeyA, childKeyB, nil)
if store.IsNotFound(err) {
log.Printf(" Not Found Key: %d, %d ChildKey: %d, %d", keyA, keyB, childKeyA, childKeyB)
return "", nil
} else if err != nil {
return "", err
}
log.Println("Successfully read an item from the Group Store")
return fmt.Sprintf("%s", value), nil
}
func (o *OortFS) Remove(ctx context.Context, parent []byte, name string) (int32, error) {
v, err := o.validateIP(ctx)
if err != nil {
return 1, err
}
if !v {
return 1, errors.New("Unknown or unauthorized FS use")
}
// 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 = proto.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 = proto.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) Symlink(ctx context.Context, parent, id []byte, name string, target string, attr *pb.Attr, inode uint64) (*pb.SymlinkResponse, error) {
v, err := o.validateIP(ctx)
if err != nil {
return nil, err
}
if !v {
return nil, errors.New("Unknown or unauthorized FS use")
}
// Check to see if the name exists
val, err := o.comms.ReadGroupItem(ctx, parent, []byte(name))
if err != nil && !store.IsNotFound(err) {
// TODO: Needs beter error handling
return &pb.SymlinkResponse{}, err
}
if len(val) > 1 { // Exists already
return &pb.SymlinkResponse{}, nil
}
n := &pb.InodeEntry{
Version: InodeEntryVersion,
Inode: inode,
IsDir: false,
IsLink: true,
Target: target,
Attr: attr,
}
b, err := proto.Marshal(n)
if err != nil {
return &pb.SymlinkResponse{}, err
}
err = o.WriteChunk(ctx, id, b)
if err != nil {
return &pb.SymlinkResponse{}, err
}
// Add the name to the group
d := &pb.DirEntry{
Version: DirEntryVersion,
Name: name,
Id: id,
}
b, err = proto.Marshal(d)
if err != nil {
return &pb.SymlinkResponse{}, err
}
err = o.comms.WriteGroup(ctx, parent, []byte(name), b)
if err != nil {
return &pb.SymlinkResponse{}, err
}
return &pb.SymlinkResponse{Name: name, Attr: attr}, 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 = proto.Unmarshal(b, d)
if err != nil {
return &pb.DirEntry{}, err
}
return d, 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 = proto.Unmarshal(b, fb)
if err != nil {
return nil, err
}
// TODO: Validate checksum and handle errors
return fb.Data, nil
}
// grpc Group Store functions
// lookupAccount ...
func (fsws *FileSystemWS) readGroupGStore(g string) (string, error) {
log.Println("Starting a Group Store Lookup")
keyA, keyB := murmur3.Sum128([]byte(g))
items, err := fsws.gstore.ReadGroup(context.Background(), keyA, keyB)
if store.IsNotFound(err) {
log.Printf("Not Found: %s", g)
return "", nil
} else if err != nil {
return "", err
}
// Build a list of accounts.
log.Println("Build a list of file systems")
m := make([]string, len(items))
for k, v := range items {
m[k] = fmt.Sprintf("%s", v.Value)
}
log.Println("Returning a list of file systems")
return fmt.Sprintf(strings.Join(m, "|")), nil
}
func (s *apiServer) validateIP(ctx context.Context) error {
if s.comms == nil {
// TODO: Fix abstraction so that we don't have to do this for tests
// Assume that it is a unit test
return nil
}
p, ok := peer.FromContext(ctx)
if !ok {
return errors.New("Couldn't get client IP")
}
ip, _, err := net.SplitHostPort(p.Addr.String())
if err != nil {
return err
}
fsidUUID, err := GetFsId(ctx)
fsid := fsidUUID.String()
if err != nil {
return err
}
// First check the cache
ips, ok := s.validIPs[fsid]
if !ok {
ips = make(map[string]bool)
s.validIPs[fsid] = ips
}
valid, ok := ips[ip]
if ok && valid {
return nil
}
_, err = s.comms.ReadGroupItem(ctx, []byte(fmt.Sprintf("/fs/%s/addr", fsid)), []byte(ip))
if store.IsNotFound(err) {
log.Println("Invalid IP: ", ip)
// No access
return ErrUnauthorized
}
if err != nil {
return err
}
// Cache the valid ip
s.validIPs[fsid][ip] = true
return nil
}
// addrList ...
func (s *FileSystemAPIServer) addrList(fsid string) ([]string, error) {
var ap AddrPayLoad
pKey := fmt.Sprintf("/fs/%s/addr", fsid)
pKeyA, pKeyB := murmur3.Sum128([]byte(pKey))
items, err := s.fsws.gstore.ReadGroup(context.Background(), pKeyA, pKeyB)
if store.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
l := make([]string, len(items))
for k, v := range items {
err = json.Unmarshal(v.Value, &ap)
if err != nil {
return nil, err
}
l[k] = ap.Addr
}
return l, nil
}
// LookupAddrFS ...
func (s *FileSystemAPIServer) LookupAddrFS(ctx context.Context, r *fb.LookupAddrFSRequest) (*fb.LookupAddrFSResponse, error) {
var err error
var status string
// Check if IP is assigned to the file system
parentKey := fmt.Sprintf("/fs/%s/addr", r.FSid)
pKeyA, pKeyB := murmur3.Sum128([]byte(parentKey))
cKeyA, cKeyB := murmur3.Sum128([]byte(r.Addr))
_, _, err = s.fsws.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
log.Printf("/fs/%s/addr/%s did not exist to delete", r.FSid, r.Addr)
return nil, errf(codes.NotFound, "%s", "Addr not found")
} else if err != nil {
return nil, errf(codes.Internal, "%s", err)
}
//
// Verify Account is activea
status = "OK"
return &fb.LookupAddrFSResponse{Status: status}, nil
}
func (o *OortFS) GetDirent(ctx context.Context, parent []byte, name string) (*pb.DirEntry, error) {
v, err := o.validateIP(ctx)
if err != nil {
return nil, err
}
if !v {
return nil, errors.New("Unknown or unauthorized FS use")
}
// 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 = proto.Unmarshal(b, d)
if err != nil {
return &pb.DirEntry{}, err
}
return d, nil
}
func (o *OortFS) validateIP(ctx context.Context) (bool, error) {
// TODO: Add caching of validation
p, ok := peer.FromContext(ctx)
if !ok {
return false, errors.New("Couldn't get client IP")
}
if p.Addr.String() == "internal" {
// This is an internal call, so we can skip
return true, nil
}
ip, _, err := net.SplitHostPort(p.Addr.String())
if err != nil {
return false, err
}
// First check the cache
valid, ok := o.validIps[ip]
if ok && valid {
return true, nil
}
fsid, err := GetFsId(ctx)
if err != nil {
return false, err
}
_, err = o.comms.ReadGroupItem(ctx, []byte(fmt.Sprintf("/fs/%s/addr", fsid.String())), []byte(ip))
if store.IsNotFound(err) {
log.Println("Invalid IP: ", ip)
// No access
return false, nil
}
if err != nil {
return false, err
}
// Cache the valid ip
o.validIps[ip] = true
return true, nil
}
func (o *OortFS) GetChunk(ctx context.Context, id []byte) ([]byte, error) {
v, err := o.validateIP(ctx)
if err != nil {
return nil, err
}
if !v {
return nil, errors.New("Unknown or unauthorized FS use")
}
b, err := o.comms.ReadValue(ctx, id)
if store.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
fb := &pb.FileBlock{}
err = proto.Unmarshal(b, fb)
if err != nil {
return nil, err
}
// TODO: Validate checksum and handle errors
return fb.Data, nil
}
// RevokeAddrFS ...
func (s *FileSystemAPIServer) RevokeAddrFS(ctx context.Context, r *fb.RevokeAddrFSRequest) (*fb.RevokeAddrFSResponse, error) {
var status string
var err error
var acctData AcctPayLoad
// Get incomming ip
pr, ok := peer.FromContext(ctx)
if ok {
fmt.Println(pr.Addr)
}
// getAcct data
acctData, err = s.getAcct("/acct", r.Acctnum)
if err != nil {
log.Printf("Error %v on lookup for account %s", err, r.Acctnum)
return nil, errf(codes.NotFound, "%v", err)
}
// validate token
if acctData.Token != r.Token {
return nil, errf(codes.PermissionDenied, "%s", "Invalid Token")
}
parentKey := fmt.Sprintf("/fs/%s/addr", r.FSid)
childKey := r.Addr
parentKeyA, parentKeyB := murmur3.Sum128([]byte(parentKey))
childKeyA, childKeyB := murmur3.Sum128([]byte(childKey))
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
// Delete addr
_, err = s.fsws.gstore.Delete(context.Background(), parentKeyA, parentKeyB, childKeyA, childKeyB, timestampMicro)
if store.IsNotFound(err) {
log.Printf("/fs/%s/addr/%s did not exist to delete", r.FSid, r.Addr)
return nil, errf(codes.NotFound, "%s", "Addr not found")
} else if err != nil {
return nil, errf(codes.Internal, "%s", err)
}
// DO stuff
status = fmt.Sprintf("addr %s for filesystem %s with account id %s was revoked", r.Addr, r.FSid, r.Acctnum)
return &fb.RevokeAddrFSResponse{Status: status}, nil
}
func (rs *ReplValueStore) Read(ctx context.Context, keyA uint64, keyB uint64, value []byte) (int64, []byte, error) {
type rettype struct {
timestampMicro int64
value []byte
err ReplValueStoreError
}
ec := make(chan *rettype)
stores, err := rs.storesFor(ctx, keyA)
if err != nil {
rs.logDebug("replValueStore Read %x %x: error from storesFor: %s", keyA, keyB, err)
return 0, nil, err
}
for _, s := range stores {
go func(s *replValueStoreAndTicketChan) {
ret := &rettype{}
var err error
select {
case <-s.ticketChan:
ret.timestampMicro, ret.value, err = s.store.Read(ctx, keyA, keyB, nil)
s.ticketChan <- struct{}{}
case <-ctx.Done():
err = ctx.Err()
}
if err != nil {
ret.err = &replValueStoreError{store: s.store, err: err}
}
ec <- ret
}(s)
}
var timestampMicro int64
var rvalue []byte
var hadNotFoundErr bool
var errs ReplValueStoreErrorSlice
for _ = range stores {
ret := <-ec
if ret.timestampMicro > timestampMicro || timestampMicro == 0 {
timestampMicro = ret.timestampMicro
rvalue = ret.value
hadNotFoundErr = ret.err != nil && store.IsNotFound(ret.err.Err())
}
if ret.err != nil {
errs = append(errs, ret.err)
}
}
if value != nil && rvalue != nil {
rvalue = append(value, rvalue...)
}
for _, err := range errs {
rs.logDebug("replValueStore Read %x %x: error during read: %s", keyA, keyB, err)
}
if hadNotFoundErr {
nferrs := make(ReplValueStoreErrorNotFound, len(errs))
for i, v := range errs {
nferrs[i] = v
}
rs.logDebug("replValueStore Read %x %x: returning at point1: %d %q %v", keyA, keyB, timestampMicro, rvalue, nferrs)
return timestampMicro, rvalue, nferrs
}
if len(errs) < len(stores) {
errs = nil
}
if errs == nil {
rs.logDebug("replValueStore Read %x %x: returning at point2: %d %q", keyA, keyB, timestampMicro, rvalue)
return timestampMicro, rvalue, nil
}
rs.logDebug("replValueStore Read %x %x: returning at point3: %d %q %v", keyA, keyB, timestampMicro, rvalue, errs)
return timestampMicro, rvalue, errs
}
func (rs *ReplValueStore) Lookup(ctx context.Context, keyA, keyB uint64) (int64, uint32, error) {
type rettype struct {
timestampMicro int64
length uint32
err ReplValueStoreError
}
ec := make(chan *rettype)
stores, err := rs.storesFor(ctx, keyA)
if err != nil {
return 0, 0, err
}
for _, s := range stores {
go func(s *replValueStoreAndTicketChan) {
ret := &rettype{}
var err error
select {
case <-s.ticketChan:
ret.timestampMicro, ret.length, err = s.store.Lookup(ctx, keyA, keyB)
s.ticketChan <- struct{}{}
case <-ctx.Done():
err = ctx.Err()
}
if err != nil {
ret.err = &replValueStoreError{store: s.store, err: err}
}
ec <- ret
}(s)
}
var timestampMicro int64
var length uint32
var hadNotFoundErr bool
var errs ReplValueStoreErrorSlice
for _ = range stores {
ret := <-ec
if ret.timestampMicro > timestampMicro || timestampMicro == 0 {
timestampMicro = ret.timestampMicro
length = ret.length
hadNotFoundErr = ret.err != nil && store.IsNotFound(ret.err.Err())
}
if ret.err != nil {
errs = append(errs, ret.err)
}
}
if hadNotFoundErr {
nferrs := make(ReplValueStoreErrorNotFound, len(errs))
for i, v := range errs {
nferrs[i] = v
}
return timestampMicro, length, nferrs
}
if len(errs) < len(stores) {
for _, err := range errs {
rs.logDebug("replValueStore: error during lookup: %s", err)
}
errs = nil
}
if errs == nil {
return timestampMicro, length, nil
}
return timestampMicro, length, errs
}
// ListFS ...
func (s *FileSystemAPIServer) ListFS(ctx context.Context, r *pb.ListFSRequest) (*pb.ListFSResponse, error) {
srcAddr := ""
// Get incomming ip
pr, ok := peer.FromContext(ctx)
if ok {
srcAddr = pr.Addr.String()
}
// Validate Token
acctID, err := s.validateToken(r.Token)
if err != nil {
log.Printf("%s LIST FAILED %s\n", srcAddr, "PermissionDenied")
return nil, errf(codes.PermissionDenied, "%v", "Invalid Token")
}
var value []byte
var fsRef FileSysRef
var addrData AddrRef
var fsAttrData FileSysAttr
var aList []string
// Read Group /acct/acctID _ FileSysRef
pKey := fmt.Sprintf("/acct/%s", acctID)
pKeyA, pKeyB := murmur3.Sum128([]byte(pKey))
list, err := s.gstore.ReadGroup(context.Background(), pKeyA, pKeyB)
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
fsList := make([]FileSysMeta, len(list))
for k, v := range list {
clear(&fsRef)
clear(&addrData)
clear(&fsAttrData)
clear(&aList)
err = json.Unmarshal(v.Value, &fsRef)
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
fsList[k].AcctID = acctID
fsList[k].ID = fsRef.FSID
// Get File System Name
pKey = fmt.Sprintf("/fs/%s", fsList[k].ID)
pKeyA, pKeyB = murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB := murmur3.Sum128([]byte("name"))
_, value, err = s.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
log.Printf("%s LIST FAILED %s NAMENOTFOUND", srcAddr, fsList[k].ID)
return nil, errf(codes.NotFound, "%v", "File System Name Not Found")
}
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
err = json.Unmarshal(value, &fsAttrData)
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
fsList[k].Name = fsAttrData.Value
// Get List of addrs
pKey = fmt.Sprintf("/fs/%s/addr", fsList[k].ID)
pKeyA, pKeyB = murmur3.Sum128([]byte(pKey))
items, err := s.gstore.ReadGroup(context.Background(), pKeyA, pKeyB)
if !store.IsNotFound(err) {
// No addr granted
aList = make([]string, len(items))
for sk, sv := range items {
err = json.Unmarshal(sv.Value, &addrData)
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
aList[sk] = addrData.Addr
}
}
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
fsList[k].Addr = aList
}
// Return a File System List
fsListJSON, jerr := json.Marshal(&fsList)
if jerr != nil {
return nil, errf(codes.Internal, "%s", jerr)
}
// Log Operation
log.Printf("%s LIST SUCCESS %s\n", srcAddr, acctID)
return &pb.ListFSResponse{Data: string(fsListJSON)}, nil
}
// ShowFS ...
func (s *FileSystemAPIServer) ShowFS(ctx context.Context, r *pb.ShowFSRequest) (*pb.ShowFSResponse, error) {
var err error
var acctID string
srcAddr := ""
// Get incomming ip
pr, ok := peer.FromContext(ctx)
if ok {
srcAddr = pr.Addr.String()
}
// Validate Token
acctID, err = s.validateToken(r.Token)
if err != nil {
log.Printf("%s SHOW FAILED %s\n", srcAddr, "PermissionDenied")
return nil, errf(codes.PermissionDenied, "%v", "Invalid Token")
}
var fs FileSysMeta
var value []byte
var fsRef FileSysRef
var addrData AddrRef
var fsAttrData FileSysAttr
var aList []string
fs.ID = r.FSid
// Read FileSysRef entry to determine if it exists
pKey := fmt.Sprintf("/fs")
pKeyA, pKeyB := murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB := murmur3.Sum128([]byte(fs.ID))
_, value, err = s.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
log.Printf("%s SHOW FAILED %s NOTFOUND", srcAddr, r.FSid)
return nil, errf(codes.NotFound, "%v", "Not Found")
}
if err != nil {
log.Printf("%s SHOW FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
err = json.Unmarshal(value, &fsRef)
if err != nil {
log.Printf("%s SHOW FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
// Validate Token/Account own the file system
if fsRef.AcctID != acctID {
log.Printf("$s SHOW FAILED %v ACCOUNT MISMATCH", fs.ID)
return nil, errf(codes.FailedPrecondition, "%v", "Account Mismatch")
}
fs.AcctID = fsRef.AcctID
// Read the file system attributes
// group-lookup /fs FSID
// Iterate over all the atributes
pKey = fmt.Sprintf("/fs/%s", fs.ID)
pKeyA, pKeyB = murmur3.Sum128([]byte(pKey))
cKeyA, cKeyB = murmur3.Sum128([]byte("name"))
_, value, err = s.gstore.Read(context.Background(), pKeyA, pKeyB, cKeyA, cKeyB, nil)
if store.IsNotFound(err) {
log.Printf("%s SHOW FAILED %s NAMENOTFOUND", srcAddr, r.FSid)
return nil, errf(codes.NotFound, "%v", "File System Name Not Found")
}
if err != nil {
log.Printf("%s SHOW FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
err = json.Unmarshal(value, &fsAttrData)
if err != nil {
log.Printf("%s SHOW FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
fs.Name = fsAttrData.Value
// Read list of granted ip addresses
// group-lookup printf("/fs/%s/addr", FSID)
pKey = fmt.Sprintf("/fs/%s/addr", fs.ID)
pKeyA, pKeyB = murmur3.Sum128([]byte(pKey))
items, err := s.gstore.ReadGroup(context.Background(), pKeyA, pKeyB)
if !store.IsNotFound(err) {
// No addr granted
aList = make([]string, len(items))
for k, v := range items {
err = json.Unmarshal(v.Value, &addrData)
if err != nil {
log.Printf("%s LIST FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
aList[k] = addrData.Addr
}
}
if err != nil {
log.Printf("%s SHOW FAILED %v\n", srcAddr, err)
return nil, errf(codes.Internal, "%v", err)
}
fs.Addr = aList
// Return File System
fsJSON, jerr := json.Marshal(&fs)
if jerr != nil {
return nil, errf(codes.Internal, "%s", jerr)
}
// Log Operation
log.Printf("%s SHOW SUCCESS %s\n", srcAddr, r.FSid)
return &pb.ShowFSResponse{Data: string(fsJSON)}, nil
}
func (c *Client) parseGroupCmd(line string) (string, error) {
if c.gstore == nil {
err := c.getGroupClient()
if err != nil {
return "", err
}
}
split := strings.SplitN(line, " ", 2)
cmd := split[0]
if len(split) != 2 {
if cmd == "exit" {
return "", fmt.Errorf("Exiting..")
}
if cmd == "help" {
return c.printHelp(), nil
}
return c.printHelp(), nil
}
args := split[1]
switch cmd {
case "write":
sarg := strings.SplitN(args, " ", 3)
if len(sarg) < 3 {
return fmt.Sprintf("write needs groupkey, key, value: `write groupkey somekey some value thing here`"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
childKeyA, childKeyB := murmur3.Sum128([]byte(sarg[1]))
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
oldTimestampMicro, err := c.gstore.Write(context.Background(), keyA, keyB, childKeyA, childKeyB, timestampMicro, []byte(sarg[2]))
if err != nil {
return "", err
}
return fmt.Sprintf("WRITE TIMESTAMPMICRO: %d\nPREVIOUS TIMESTAMPMICRO: %d", timestampMicro, oldTimestampMicro), nil
case "write-hash":
sarg := strings.SplitN(args, " ", 4)
if len(sarg) < 4 {
return fmt.Sprintf("write-hash needs groupkey, keyahash keybhash, value: `write-hash groupkey 19191919 19191919 some value thing here`"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
childKeyA, err := strconv.ParseUint(sarg[1], 10, 64)
if err != nil {
return "", err
}
childKeyB, err := strconv.ParseUint(sarg[2], 10, 64)
if err != nil {
return "", err
}
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
oldTimestampMicro, err := c.gstore.Write(context.Background(), keyA, keyB, childKeyA, childKeyB, timestampMicro, []byte(sarg[3]))
if err != nil {
return "", err
}
return fmt.Sprintf("WRITE TIMESTAMPMICRO: %d\n PREVIOUS TIMESTAMPMICRO: %d", timestampMicro, oldTimestampMicro), nil
case "read":
sarg := strings.SplitN(args, " ", 2)
if len(sarg) < 2 {
return fmt.Sprintf("read needs groupkey, subkey"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
childKeyA, childKeyB := murmur3.Sum128([]byte(sarg[1]))
timestampMicro, value, err := c.gstore.Read(context.Background(), keyA, keyB, childKeyA, childKeyB, nil)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nVALUE: %s", timestampMicro, value), nil
case "read-hash":
sarg := strings.SplitN(args, " ", 3)
if len(sarg) < 3 {
return fmt.Sprintf("read needs groupkey, subkeyA, subkeyB"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
childKeyA, err := strconv.ParseUint(sarg[1], 10, 64)
if err != nil {
return "", err
}
childKeyB, err := strconv.ParseUint(sarg[2], 10, 64)
if err != nil {
return "", err
}
timestampMicro, value, err := c.gstore.Read(context.Background(), keyA, keyB, childKeyA, childKeyB, nil)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nVALUE: %s", timestampMicro, value), nil
case "read-group":
KeyA, KeyB := murmur3.Sum128([]byte(args))
items, err := c.gstore.ReadGroup(context.Background(), KeyA, KeyB)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
keys := make([]string, len(items))
for k, v := range items {
keys[k] = fmt.Sprintf("TIMESTAMPMICRO: %d [ %d | %d] VALUE: %s", v.TimestampMicro, v.ChildKeyA, v.ChildKeyB, v.Value)
}
return fmt.Sprintf(strings.Join(keys, "\n")), nil
case "delete":
sarg := strings.SplitN(args, " ", 2)
if len(sarg) < 2 {
return fmt.Sprintf("delete needs groupkey, subkey"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
childKeyA, childKeyB := murmur3.Sum128([]byte(sarg[1]))
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
oldTimestampMicro, err := c.gstore.Delete(context.Background(), keyA, keyB, childKeyA, childKeyB, timestampMicro)
if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nOLD TIMESTAMPMICRO: %d", timestampMicro, oldTimestampMicro), nil
case "lookup":
sarg := strings.SplitN(args, " ", 2)
if len(sarg) < 2 {
return fmt.Sprintf("lookup needs groupkey, subkey"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
childKeyA, childKeyB := murmur3.Sum128([]byte(sarg[1]))
timestampMicro, length, err := c.gstore.Lookup(context.Background(), keyA, keyB, childKeyA, childKeyB)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nLENGTH: %d", timestampMicro, length), nil
case "lookup-group":
keyA, keyB := murmur3.Sum128([]byte(args))
items, err := c.gstore.LookupGroup(context.Background(), keyA, keyB)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
keys := make([]string, len(items))
for k, v := range items {
keys[k] = fmt.Sprintf("TIMESTAMPMICRO: %d [ %d | %d ]", v.TimestampMicro, v.ChildKeyA, v.ChildKeyB)
}
return fmt.Sprintf(strings.Join(keys, "\n")), nil
case "mode":
if args == "value" {
c.gmode = false
return fmt.Sprintf("Switched to value mode"), nil
}
if args == "group" {
return fmt.Sprintf("Already in group store mode"), nil
}
return fmt.Sprintf("Valid modes are: value | group"), nil
case "exit":
log.Println("exit")
return "", fmt.Errorf("Exiting..")
}
return c.printHelp(), nil
}
func (c *Client) parseValueCmd(line string) (string, error) {
if c.vconn == nil {
err := c.getValueClient()
if err != nil {
return "", err
}
}
split := strings.SplitN(line, " ", 2)
cmd := split[0]
if len(split) != 2 {
if cmd == "exit" {
return "", fmt.Errorf("Exiting..")
}
if cmd == "help" {
return c.printHelp(), nil
}
return c.printHelp(), nil
}
args := split[1]
switch cmd {
case "write":
sarg := strings.SplitN(args, " ", 2)
if len(sarg) < 2 {
return fmt.Sprintf("write needs key and value: `write somekey some value thing here`"), nil
}
keyA, keyB := murmur3.Sum128([]byte(sarg[0]))
value := []byte(sarg[1])
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
oldTimestampMicro, err := c.vstore.Write(context.Background(), keyA, keyB, timestampMicro, value)
if err != nil {
return "", err
}
return fmt.Sprintf("WRITE TIMESTAMPMICRO: %d\nPREVIOUS TIMESTAMPMICRO: %d", timestampMicro, oldTimestampMicro), nil
case "read":
keyA, keyB := murmur3.Sum128([]byte(args))
timestampMicro, value, err := c.vstore.Read(context.Background(), keyA, keyB, nil)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nVALUE: %s", timestampMicro, value), nil
case "delete":
keyA, keyB := murmur3.Sum128([]byte(args))
timestampMicro := brimtime.TimeToUnixMicro(time.Now())
oldTimestampMicro, err := c.vstore.Delete(context.Background(), keyA, keyB, timestampMicro)
if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nOLD TIMESTAMPMICRO: %d", timestampMicro, oldTimestampMicro), nil
case "lookup":
keyA, keyB := murmur3.Sum128([]byte(args))
timestampMicro, length, err := c.vstore.Lookup(context.Background(), keyA, keyB)
if store.IsNotFound(err) {
return fmt.Sprintf("not found"), nil
} else if err != nil {
return "", err
}
return fmt.Sprintf("TIMESTAMPMICRO: %d\nLENGTH: %d", timestampMicro, length), nil
case "mode":
if args == "value" {
return fmt.Sprintf("Already in value store mode"), nil
}
if args == "group" {
c.gmode = true
return fmt.Sprintf("Switched to group mode"), nil
}
return fmt.Sprintf("Valid modes are: value | group"), nil
case "exit":
log.Println("exit")
return "", fmt.Errorf("Exiting..")
}
return c.printHelp(), nil
}