Plumb through blacklist flag in exparchive.

client/cmd/isolate/exp_archive.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,
@@ skipping 135 matching lines @@
                 pw.parts.links.AddItem(item)
         case item.Size < archiveThreshold:
                 pw.parts.filesToArchive.AddItem(item)
         default:
                 pw.parts.indivFiles.AddItem(item)
         }
         return nil
 }
 
 // partitionDeps walks each of the deps, partioning the results into symlinks and files categorized by size.
-func partitionDeps(deps []string, rootDir string) (partitionedDeps, error) {
-        // TODO(mcgreevy): initialize FilesystemView with blacklist.
-        fsView, err := common.NewFilesystemView(rootDir, nil)
+func partitionDeps(deps []string, rootDir string, blacklist []string) (partitionedDeps, error) {
+        fsView, err := common.NewFilesystemView(rootDir, blacklist)
         if err != nil {
                 return partitionedDeps{}, err
         }
 
         walker := partitioningWalker{fsView: fsView}
         for _, dep := range deps {
                 // Try to walk dep. If dep is a file (or symlink), the inner function is called exactly once.
                 if err := filepath.Walk(filepath.Clean(dep), walker.walkFn); err != nil {
                         return partitionedDeps{}, err
                 }
@@ skipping 26 matching lines @@
         }
         client := isolatedclient.New(nil, authCl, c.isolatedFlags.ServerURL, c.isolatedFlags.Namespace, nil, nil)
 
         // Set up a checker and uploader. We limit the uploader to one concurrent
         // upload, since the uploads are all coming from disk (with the exception of
         // the isolated JSON itself) and we only want a single goroutine reading from
         // disk at once.
         checker := NewChecker(ctx, client)
         uploader := NewUploader(ctx, client, 1)
 
-        parts, err := partitionDeps(deps, rootDir)
+        parts, err := partitionDeps(deps, rootDir, c.isolateFlags.ArchiveOptions.Blacklist)
         if err != nil {
                 return fmt.Errorf("partitioning deps: %v", err)
         }
 
         // Construct a map of the files that constitute the isolate.
         files := make(map[string]isolated.File)
 
         numFiles := len(parts.filesToArchive.items) + len(parts.indivFiles.items)
         filesSize := uint64(parts.filesToArchive.totalSize + parts.indivFiles.totalSize)
         log.Printf("Isolate expanded to %d files (total size %s) and %d symlinks", numFiles, humanize.Bytes(filesSize), len(parts.links.items))
@@ skipping 156 matching lines @@
         }
         return nil
 }
 
 func (c *expArchiveRun) Run(a subcommands.Application, args []string, _ subcommands.Env) int {
         fmt.Fprintln(a.GetErr(), "WARNING: this command is experimental")
         if err := c.parseFlags(args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
-        if len(c.isolateFlags.ArchiveOptions.Blacklist) != 0 {
-                fmt.Fprintf(a.GetErr(), "%s: blacklist is not supported\n", a.GetName())
-                return 1
-        }
         if err := c.main(); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         return 0
 }
 
 func hashFile(path string) (isolated.HexDigest, error) {
         f, err := os.Open(path)
         if err != nil {
                 return "", err
         }
         defer f.Close()
         return isolated.Hash(f)
 }