Ignore traces

golden/go/filediffstore/filediffstore.go

 package filediffstore
 
 import (
         "bytes"
         "crypto/md5"
         "encoding/base64"
         "encoding/json"
         "fmt"
         "image"
         "io"
@@ skipping 94 matching lines @@
         // The GS bucket where images are stored.
         gsBucketName string
 
         // The complete GS URL where images are stored.
         storageBaseDir string
 
         // The channels workers pick up tasks from.
         absPathCh chan *WorkerReq
         getCh     chan *WorkerReq
 
-        // ignoreableDigests contains the digests that should be ignored.
-        ignorableDigests map[string]bool
+        // unavailableDigests contains the digests that should be ignored.
+        unavailableDigests map[string]bool
 
-        // idChan is a channel to add to ignorableDigests.
-        ignorableChan chan string
+        // idChan is a channel to add to unavailableDigests.
+        unavailableChan chan string
 
-        // Mutex for the ignorable Channel
-        ignorableMutex sync.Mutex
+        // unavailableMutex protects unavailableDigests
+        unavailableMutex sync.Mutex
 
         // Mutexes for ensuring safe access to the different local caches.
         diffDirLock   sync.Mutex
         digestDirLock sync.Mutex
 }
 
 // NewFileDiffStore intializes and returns a file based implementation of
 // DiffStore. The optional http.Client is used to make HTTP requests to Google
 // Storage. If nil is supplied then a default client is used. The baseDir is the
 // local base directory where the DEFAULT_IMG_DIR_NAME, DEFAULT_DIFF_DIR_NAME and
@@ skipping 11 matching lines @@
         if storageBaseDir == "" {
                 storageBaseDir = DEFAULT_GS_IMG_DIR_NAME
         }
 
         imageCache, err := lru.New(IMAGE_LRU_CACHE_SIZE)
         if err != nil {
                 return nil, fmt.Errorf("Unable to alloace image LRU cache: %s", err)
         }
 
         diffCache := cacheFactory("di", DiffMetricsCodec(0))
-        ignorableChan := make(chan string, 10)
+        unavailableChan := make(chan string, 10)
 
         fs := &FileDiffStore{
                 client:              client,
                 localImgDir:         fileutil.Must(fileutil.EnsureDirExists(filepath.Join(baseDir, DEFAULT_IMG_DIR_NAME))),
                 localDiffDir:        fileutil.Must(fileutil.EnsureDirExists(filepath.Join(baseDir, DEFAULT_DIFF_DIR_NAME))),
                 localDiffMetricsDir: fileutil.Must(fileutil.EnsureDirExists(filepath.Join(baseDir, DEFAULT_DIFFMETRICS_DIR_NAME))),
                 localTempFileDir:    fileutil.Must(fileutil.EnsureDirExists(filepath.Join(baseDir, DEFAULT_TEMPFILE_DIR_NAME))),
                 gsBucketName:        gsBucketName,
                 storageBaseDir:      storageBaseDir,
                 imageCache:          imageCache,
                 diffCache:           diffCache,
-                ignorableDigests:    map[string]bool{},
-                ignorableChan:       ignorableChan,
+                unavailableDigests:  map[string]bool{},
+                unavailableChan:     unavailableChan,
         }
 
         // TODO(stephana): Clean this up and store digests to ignore in the
         // database and expose them on the front-end.
         // This is the hash of the empty, we should ignore this right away.
-        ignorableChan <- "d41d8cd98f00b204e9800998ecf8427e"
+        unavailableChan <- "d41d8cd98f00b204e9800998ecf8427e"
         go func() {
                 var ignoreDigest string
                 for {
-                        ignoreDigest = <-ignorableChan
+                        ignoreDigest = <-unavailableChan
                         func() {
-                                fs.ignorableMutex.Lock()
-                                defer fs.ignorableMutex.Unlock()
-                                fs.ignorableDigests[ignoreDigest] = true
+                                fs.unavailableMutex.Lock()
+                                defer fs.unavailableMutex.Unlock()
+                                fs.unavailableDigests[ignoreDigest] = true
                         }()
                 }
         }()
 
         fs.activateWorkers(workerPoolSize)
         return fs, nil
 }
 
 type WorkerReq struct {
         id     interface{}
@@ skipping 203 matching lines @@
                         }
                         if (len(digestsToPaths) + digestErrors) == len(digests) {
                                 // 4. Return map of digests to paths once all requests have
                                 //    been processed.
                                 return digestsToPaths
                         }
                 }
         }
 }
 
-// IgnorableDigests is part of the diff.DiffStore interface. See details there.
-func (fs *FileDiffStore) IgnorableDigests() map[string]bool {
-        fs.ignorableMutex.Lock()
-        defer fs.ignorableMutex.Unlock()
-        result := make(map[string]bool, len(fs.ignorableDigests))
-        for k, v := range fs.ignorableDigests {
+// UnavailableDigests is part of the diff.DiffStore interface. See details there.
+func (fs *FileDiffStore) UnavailableDigests() map[string]bool {
+        fs.unavailableMutex.Lock()
+        defer fs.unavailableMutex.Unlock()
+        result := make(map[string]bool, len(fs.unavailableDigests))
+        for k, v := range fs.unavailableDigests {
                 result[k] = v
         }
         return result
 }
 
 func openDiffMetrics(filepath string) (*diff.DiffMetrics, error) {
         f, err := ioutil.ReadFile(filepath)
         if err != nil {
                 return nil, fmt.Errorf("Failed to open DiffMetrics %s for reading: %s", filepath, err)
         }
@@ skipping 231 matching lines @@
         if obj, ok := fs.imageCache.Get(d); ok {
                 return obj.(image.Image), nil
         }
         img, err = diff.OpenImage(fs.getDigestImagePath(d))
         if err == nil {
                 fs.imageCache.Add(d, img)
                 return img, nil
         }
 
         // Mark the image as ignorable since we were not able to decode it.
-        fs.ignorableChan <- d
+        fs.unavailableChan <- d
 
         return nil, fmt.Errorf("Unable to read image for %s: %s", d, err)
 }
 
 // getDigestPath returns the filepath where the image corresponding to the
 // give digests should be stored.
 func (fs *FileDiffStore) getDigestImagePath(digest string) string {
         return filepath.Join(fs.localImgDir, fmt.Sprintf("%s.%s", digest, IMG_EXTENSION))
 }
 
 // getDiffMetricPath returns the filename where the diffmetric should be
 // cached.
 func (fs *FileDiffStore) getDiffMetricPath(baseName string) string {
         fName := fmt.Sprintf("%s.%s", baseName, DIFFMETRICS_EXTENSION)
         return filepath.Join(fs.localDiffMetricsDir, fName)
 }