isolate: clean up some path handling

client/archiver/directory.go

 // Copyright 2015 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package archiver
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "log"
         "os"
         "path/filepath"
-        "strings"
 
         "github.com/luci/luci-go/common/isolated"
         "github.com/luci/luci-go/common/isolatedclient"
         "github.com/luci/luci-go/common/runtime/tracer"
 )
 
 type walkItem struct {
         fullPath string
         relPath  string
         info     os.FileInfo
@@ skipping 30 matching lines @@
         end := tracer.Span(root, "walk:"+filepath.Base(root), nil)
         defer func() { end(tracer.Args{"root": root, "total": total}) }()
         // Check patterns upfront, so it has consistent behavior w.r.t. bad glob
         // patterns.
         for _, b := range blacklist {
                 if _, err := filepath.Match(b, b); err != nil {
                         c <- &walkItem{err: fmt.Errorf("bad blacklist pattern \"%s\"", b)}
                         return
                 }
         }
-        if strings.HasSuffix(root, string(filepath.Separator)) {
-                root = root[:len(root)-1]
-        }
-        rootLen := len(root) + 1
         err := filepath.Walk(root, func(p string, info os.FileInfo, err error) error {
                 total++
                 if err != nil {
                         return fmt.Errorf("walk(%q): %v", p, err)
                 }
-                if len(p) <= rootLen {
-                        // Root directory.
-                        return nil
+
+                relPath, err := filepath.Rel(root, p)
+                if err != nil {
+                        return fmt.Errorf("walk: calculating relative path(%q): %v", p, err)
                 }
-                relPath := p[rootLen:]
+
+                // filepath.Rel is documented to call filepath.Clean on its result before returning it,
+                // which results in "." for an empty relative path.
+                if relPath == "." {
+                        return nil // Root directory.
+                }
+
                 for _, b := range blacklist {
                         matched, _ := filepath.Match(b, relPath)
                         if !matched {
                                 // Also check at the base file name.
                                 matched, _ = filepath.Match(b, filepath.Base(relPath))
                         }
                         if matched {
                                 // Must not return io.SkipDir for file, filepath.walk() handles this
                                 // badly.
                                 if info.IsDir() {
@@ skipping 102 matching lines @@
                                         }
                                 }
                         }
                 }
                 if err != nil {
                         s.SetErr(err)
                 }
         }()
         return s
 }