fiddle: Don't overwrite existing fiddle names unintentionally.

fiddle/go/named/named.go

 // named is a utility for dealing with named fiddles.
 package named
 
 import (
+        "errors"
         "fmt"
         "path/filepath"
         "regexp"
         "strings"
         "sync"
 
         "github.com/skia-dev/glog"
         "go.skia.org/infra/fiddle/go/store"
 )
 
 var (
+        DuplicateNameErr = errors.New("Name already exists.")
+
         // fiddleHashRe is used to validate fiddle hashes.
         fiddleHashRe = regexp.MustCompile("^[0-9a-zA-Z]{32}$")
 
         // fiddlNameRe is used to validate fiddle names.
         fiddleNameRe = regexp.MustCompile("^[0-9a-zA-Z_]+$")
 
         // trailingToMedia maps the end of each image URL to the store.Media type
         // that it corresponds to.
         trailingToMedia = map[string]store.Media{
                 "_raster.png": store.CPU,
@@ skipping 24 matching lines @@
 // New creates a new Named.
 func New(st NameStore) *Named {
         return &Named{
                 cache: map[string]string{},
                 st:    st,
         }
 }
 
 // Add a named fiddle.
 //
-//   name - The name of the fidde, w/o the @ prefix.
-//   hash - The fiddle hash.
-//   user - The email of the user that created the name.
-func (n *Named) Add(name, hash, user string) error {
+//   name      - The name of the fidde, w/o the @ prefix.
+//   hash      - The fiddle hash.
+//   user      - The email of the user that created the name.
+//   overwrite - True if the write should proceed if the name already exists.
+func (n *Named) Add(name, hash, user string, overwrite bool) error {
         if !fiddleNameRe.MatchString(name) {
                 return fmt.Errorf("Not a valid fiddle name %q", name)
         }
         if !fiddleHashRe.MatchString(hash) {
                 return fmt.Errorf("Not a valid fiddle hash  %q", hash)
         }
         oldHash, err := n.DereferenceID("@" + name)
         if err == nil {

[rmistry, 2016/04/25 12:59:18]

I had to look at this a few times to see what it was doing. Looks like line 74
returns an err if the name does not exist yet. If there is no error means that a
name already exists. Either way its ok to write has long as overwrite is True.

+                // This name exists already.
+                if !overwrite {
+                        return DuplicateNameErr
+                }
                 if oldHash == hash {
                         // Don't bother writing if the hash is already correct.
                         return nil
                 }
                 glog.Infof("Named Fiddle Changed: %s %s -> %s by %s", name, oldHash, hash, user)
         } else {
                 glog.Infof("Named Fiddle Created: %s %s by %s", name, hash, user)
         }
         if err := n.st.WriteName(name, hash, user); err != nil {
                 return fmt.Errorf("Failed to write name: %s", err)
@@ skipping 68 matching lines @@
                 id = strings.Join(parts[:len(parts)-1], "_")
         }
         media, ok := trailingToMedia[trailing]
         if !ok {
                 return "", store.UNKNOWN, fmt.Errorf("Unknown media: %q", trailing)
         }
         // We are left with just the name or fiddle hash, dereference that.
         fiddleHash, err := n.DereferenceID(id)
         return fiddleHash, media, err
 }