Add AddressSanitizer to fuzzer analysis

fuzzer/go/backend/version_updater.go

 package backend
 
 import (
         "fmt"
         "io/ioutil"
         "os"
         "path/filepath"
         "strings"
         "sync"
         "sync/atomic"
@@ skipping 66 matching lines @@
 
         return config.Generator.SkiaVersion, nil
 }
 
 func (p *FuzzPipeline) reanalyzeAndRestart(storageClient *storage.Client, oldRevision string) error {
         // download all bad and grey fuzzes
         badFuzzNames, greyFuzzNames, err := p.downloadAllBadAndGreyFuzzes(oldRevision, storageClient)
         if err != nil {
                 return fmt.Errorf("Problem downloading all previous fuzzes: %s", err)
         }
-        glog.Infof("There are %d badFuzzNames and %d greyFuzzNames to rescan.", len(badFuzzNames), len(greyFuzzNames))
+        glog.Infof("There are %d bad fuzzes and %d grey fuzzes to rescan.", len(badFuzzNames), len(greyFuzzNames))
         // This is a soft shutdown, i.e. it waits for aggregator's queues to be empty
         p.Agg.ShutDown()
+
+        if config.Common.ForceReanalysis {
+                glog.Infof("Deleting previous fuzz results")
+                if err := gs.DeleteAllFilesInDir(storageClient, config.GS.Bucket, fmt.Sprintf("%s/%s/", p.Category, oldRevision), config.Aggregator.NumUploadProcesses); err != nil {
+                        return fmt.Errorf("Could not delete previous fuzzes: %s", err)
+                }
+        }
+
         if err := p.Gen.Clear(); err != nil {
                 return fmt.Errorf("Could not remove previous afl-fuzz results: %s", err)
         }
 
         if err := p.Agg.RestartAnalysis(); err != nil {
                 return fmt.Errorf("Had problem restarting analysis/upload chain: %s", err)
         }
         // Reanalyze and reupload the fuzzes, making a bug on regressions.
         glog.Infof("Reanalyzing bad fuzzes")
         p.Agg.MakeBugOnBadFuzz = false
@@ skipping 32 matching lines @@
         completedCounter = 0
 
         var wg sync.WaitGroup
         for i := 0; i < config.Generator.NumDownloadProcesses; i++ {
                 wg.Add(1)
                 go download(storageClient, toDownload, downloadPath, &wg)
         }
 
         badFilter := func(item *storage.ObjectAttrs) {
                 name := item.Name
-                if strings.HasSuffix(name, ".dump") || strings.HasSuffix(name, ".err") {
+                if strings.Contains(name, ".") {
                         return
                 }
                 fuzzHash := name[strings.LastIndex(name, "/")+1:]
                 badFuzzNames = append(badFuzzNames, filepath.Join(downloadPath, fuzzHash))
                 toDownload <- item.Name
         }
 
         greyFilter := func(item *storage.ObjectAttrs) {
                 name := item.Name
-                if strings.HasSuffix(item.Name, ".dump") || strings.HasSuffix(item.Name, ".err") {
+                if strings.Contains(name, ".") {
                         return
                 }
                 fuzzHash := name[strings.LastIndex(name, "/")+1:]
                 greyFuzzNames = append(greyFuzzNames, filepath.Join(downloadPath, fuzzHash))
                 toDownload <- item.Name
         }
 
         if err := gs.AllFilesInDir(storageClient, config.GS.Bucket, fmt.Sprintf("%s/%s/bad", p.Category, commitHash), badFilter); err != nil {
                 return nil, nil, fmt.Errorf("Problem getting bad fuzzes: %s", err)
         }
@@ skipping 29 matching lines @@
                 if completedCounter%100 == 0 {
                         glog.Infof("%d fuzzes downloaded", completedCounter)
                 }
         }
 }
 
 // replaceCurrentSkiaVersionWith puts the oldHash in skia_version/old and the newHash in
 // skia_version/current.  It also removes all pending versions.
 func (v *VersionUpdater) replaceCurrentSkiaVersionWith(oldHash, newHash string) error {
         // delete all pending requests
-        if err := gs.DeleteAllFilesInDir(v.storageClient, config.GS.Bucket, "skia_version/pending/"); err != nil {
+        if err := gs.DeleteAllFilesInDir(v.storageClient, config.GS.Bucket, "skia_version/pending/", 1); err != nil {
                 return err
         }
-        if err := gs.DeleteAllFilesInDir(v.storageClient, config.GS.Bucket, "skia_version/current/"); err != nil {
+        if err := gs.DeleteAllFilesInDir(v.storageClient, config.GS.Bucket, "skia_version/current/", 1); err != nil {
                 return err
         }
         if err := v.touch(fmt.Sprintf("skia_version/current/%s", newHash)); err != nil {
                 return err
         }
         return v.touch(fmt.Sprintf("skia_version/old/%s", oldHash))
 }
 
 // touch creates an empty file in Google Storage of the given name.
 func (v *VersionUpdater) touch(file string) error {
         w := v.storageClient.Bucket(config.GS.Bucket).Object(file).NewWriter(context.Background())
         if err := w.Close(); err != nil {
                 return fmt.Errorf("Could not touch version file %s : %s", file, err)
         }
         return nil
 }