func (s *server) Home(ctx context.Context, req *pb.HomeReq) (*pb.Void, error) {
traceID, err := getTraceID(ctx)
if err != nil {
rus.Error(err)
return &pb.Void{}, err
}
log := rus.WithField("trace", traceID).WithField("svc", serviceID)
ctx = newTraceContext(ctx, traceID)
log.Info("request started")
// Time request
reqStart := time.Now()
defer func() {
// Compute request duration
reqDur := time.Since(reqStart)
// Log access info
log.WithFields(rus.Fields{
"method": "home",
"type": "grpcaccess",
"duration": reqDur.Seconds(),
}).Info("request finished")
}()
idt, err := authlib.ParseToken(req.AccessToken, s.p.sharedSecret)
if err != nil {
log.Error(err)
return &pb.Void{}, unauthenticatedError
}
log.Infof("%s", idt)
home := getHome(idt)
log.Infof("user home is %s", home)
pp := s.getPhysicalPath(home)
log.Infof("user physical home is %s", pp)
resource, err := s.grpcPool.Get("")
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
defer resource.Release()
handle, err := resource.Handle()
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
con := handle.(*grpc.ClientConn)
log.Infof("created connection to %s", s.p.prop)
client := proppb.NewPropClient(con)
_, err = os.Stat(pp)
// Create home dir if not exists
if os.IsNotExist(err) {
log.Infof("user physical home %s does not exist", pp)
err = os.MkdirAll(pp, dirPerm)
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
log.Infof("user physical home created at %s", pp)
in := &proppb.GetReq{}
in.Path = home
in.AccessToken = req.AccessToken
in.ForceCreation = true
_, err = client.Get(ctx, in)
if err != nil {
return &pb.Void{}, nil
}
log.Info("home saved to %s", s.p.prop)
return &pb.Void{}, nil
}
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
log.Infof("user physical home at %s already created")
in := &proppb.GetReq{}
in.Path = home
in.AccessToken = req.AccessToken
in.ForceCreation = true
_, err = client.Get(ctx, in)
if err != nil {
return &pb.Void{}, nil
}
return &pb.Void{}, nil
}
func (s *server) Mv(ctx context.Context, req *pb.MvReq) (*pb.Void, error) {
traceID, err := getTraceID(ctx)
if err != nil {
rus.Error(err)
return &pb.Void{}, err
}
log := rus.WithField("trace", traceID).WithField("svc", serviceID)
ctx = newTraceContext(ctx, traceID)
log.Info("request started")
// Time request
reqStart := time.Now()
defer func() {
// Compute request duration
reqDur := time.Since(reqStart)
// Log access info
log.WithFields(rus.Fields{
"method": "mv",
"type": "grpcaccess",
"duration": reqDur.Seconds(),
}).Info("request finished")
}()
idt, err := authlib.ParseToken(req.AccessToken, s.p.sharedSecret)
if err != nil {
log.Error(err)
return &pb.Void{}, unauthenticatedError
}
log.Infof("%s", idt)
src := path.Clean(req.Src)
dst := path.Clean(req.Dst)
log.Infof("src is %s", src)
log.Info("dst is %s", dst)
if !isUnderHome(src, idt) {
log.Error(permissionDenied)
return &pb.Void{}, permissionDenied
}
if !isUnderHome(dst, idt) {
log.Error(permissionDenied)
return &pb.Void{}, permissionDenied
}
if src == getHome(idt) || dst == getHome(idt) {
return &pb.Void{}, grpc.Errorf(codes.PermissionDenied, "cannot rename from/to home directory")
}
psrc := s.getPhysicalPath(src)
pdst := s.getPhysicalPath(dst)
log.Infof("physical src is %s", psrc)
log.Infof("physical dst is %s", pdst)
err = os.Rename(psrc, pdst)
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
log.Infof("renamed from %s to %s", psrc, pdst)
resource, err := s.grpcPool.Get("")
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
defer resource.Release()
handle, err := resource.Handle()
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
con := handle.(*grpc.ClientConn)
log.Infof("created connection to %s", s.p.prop)
client := proppb.NewPropClient(con)
in := &proppb.MvReq{}
in.Src = src
in.Dst = dst
in.AccessToken = req.AccessToken
_, err = client.Mv(ctx, in)
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
log.Infof("renamed %s to %s in prop", src, dst)
return &pb.Void{}, nil
}
func (s *server) Rm(ctx context.Context, req *pb.RmReq) (*pb.Void, error) {
traceID, err := getTraceID(ctx)
if err != nil {
rus.Error(err)
return &pb.Void{}, err
}
log := rus.WithField("trace", traceID).WithField("svc", serviceID)
ctx = newTraceContext(ctx, traceID)
log.Info("request started")
// Time request
reqStart := time.Now()
defer func() {
// Compute request duration
reqDur := time.Since(reqStart)
// Log access info
log.WithFields(rus.Fields{
"method": "rm",
"type": "grpcaccess",
"duration": reqDur.Seconds(),
}).Info("request finished")
}()
idt, err := authlib.ParseToken(req.AccessToken, s.p.sharedSecret)
if err != nil {
log.Error(err)
return &pb.Void{}, unauthenticatedError
}
log.Infof("%s", idt)
p := path.Clean(req.Path)
log.Infof("path is %s", p)
if !isUnderHome(p, idt) {
log.Error(permissionDenied)
return &pb.Void{}, permissionDenied
}
if p == getHome(idt) {
return &pb.Void{}, grpc.Errorf(codes.PermissionDenied, "cannot remove home directory")
}
pp := s.getPhysicalPath(p)
log.Infof("physical path is %s", pp)
err = os.RemoveAll(pp)
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
log.Infof("removed %s", pp)
resource, err := s.grpcPool.Get("")
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
defer resource.Release()
handle, err := resource.Handle()
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
con := handle.(*grpc.ClientConn)
log.Infof("created connection to %s", s.p.prop)
client := proppb.NewPropClient(con)
in := &proppb.RmReq{}
in.Path = p
in.AccessToken = req.AccessToken
_, err = client.Rm(ctx, in)
if err != nil {
log.Error(err)
return &pb.Void{}, err
}
log.Infof("paths with prefix %s removed from prop", p)
return &pb.Void{}, nil
}
func (s *server) Stat(ctx context.Context, req *pb.StatReq) (*pb.Metadata, error) {
traceID, err := getTraceID(ctx)
if err != nil {
rus.Error(err)
return &pb.Metadata{}, err
}
log := rus.WithField("trace", traceID).WithField("svc", serviceID)
ctx = newTraceContext(ctx, traceID)
log.Info("request started")
// Time request
reqStart := time.Now()
defer func() {
// Compute request duration
reqDur := time.Since(reqStart)
// Log access info
log.WithFields(rus.Fields{
"method": "stat",
"type": "grpcaccess",
"duration": reqDur.Seconds(),
}).Info("request finished")
}()
idt, err := authlib.ParseToken(req.AccessToken, s.p.sharedSecret)
if err != nil {
log.Error(err)
return &pb.Metadata{}, unauthenticatedError
}
log.Infof("%s", idt)
p := path.Clean(req.Path)
log.Infof("path is %s", p)
// The hierarchy is /local/users/d/demo
// All paths in the hierarchy above the user home directory must be
// accessible for all logged in users
if isCommonDomain(p) {
} else { // it must be under /local/users/{letter}
if isUnderOtherHome(p, idt) {
if req.Children == true {
// TODO(labkode) Sharing
return &pb.Metadata{}, permissionDenied
}
} else {
// asset is under logged in user home directory
if !isUnderHome(p, idt) {
log.WithField("criticial", "").Errorf("path %s has not been handled correclty or fake path", p)
return &pb.Metadata{}, permissionDenied
}
}
}
/*
if !isUnderHome(p, idt) { // constrained to /local/users/d/demo/...
log.Error(permissionDenied)
return &pb.Metadata{}, permissionDenied
}
*/
pp := s.getPhysicalPath(p)
log.Infof("physical path is %s", pp)
parentMeta, err := s.getMeta(pp)
if err != nil {
log.Error(err)
return &pb.Metadata{}, err
}
log.Infof("stated parent %s", pp)
resource, err := s.grpcPool.Get("")
if err != nil {
log.Error(err)
return &pb.Metadata{}, err
}
defer resource.Release()
handle, err := resource.Handle()
if err != nil {
log.Error(err)
return &pb.Metadata{}, err
}
con := handle.(*grpc.ClientConn)
log.Infof("created connection to %s", s.p.prop)
client := proppb.NewPropClient(con)
in := &proppb.GetReq{}
in.Path = p
in.AccessToken = req.AccessToken
in.ForceCreation = true
rec, err := client.Get(ctx, in)
if err != nil {
log.Error(err)
return &pb.Metadata{}, err
}
parentMeta.Id = rec.Id
parentMeta.Etag = rec.Etag
parentMeta.Modified = rec.Modified
parentMeta.Checksum = rec.Checksum
if !parentMeta.IsContainer || req.Children == false {
return parentMeta, nil
}
dir, err := os.Open(pp)
if err != nil {
log.Error(err)
return &pb.Metadata{}, err
}
log.Infof("opened dir %s", pp)
defer dir.Close()
names, err := dir.Readdirnames(0)
if err != nil {
log.Error(err)
return &pb.Metadata{}, err
}
log.Infof("dir %s has %d entries", pp, len(names))
for _, n := range names {
cp := path.Join(parentMeta.Path, path.Clean(n))
cpp := s.getPhysicalPath(cp)
m, err := s.getMeta(cpp)
if err != nil {
log.Error(err)
} else {
in := &proppb.GetReq{}
in.Path = cp
in.AccessToken = req.AccessToken
in.ForceCreation = true
rec, err := client.Get(ctx, in)
if err != nil {
log.Errorf("path %s has not been added because %s", p, err.Error())
} else {
m.Id = rec.Id
m.Etag = rec.Etag
m.Modified = rec.Modified
m.Checksum = rec.Checksum
parentMeta.Children = append(parentMeta.Children, m)
log.Infof("added %s to parent", m.Path)
}
}
}
log.Infof("added %d entries to parent", len(parentMeta.Children))
return parentMeta, nil
}