LogDog: Only create missing hierarchy components.

appengine/logdog/coordinator/hierarchy/hierarchy.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package hierarchy
 
 import (
         "fmt"
         "strings"
 
@@ skipping 233 matching lines @@
                 }
                 if i == len(comps)-1 {
                         // This is the stream component.
                         cur.ID.stream = true
                 } else {
                         prev = di.NewKey("_lsnc", cur.ID.id(), 0, prev)
                 }
 
                 components = append(components, &cur)
         }
-        return di.PutMulti(components)
+
+        // See if any components are already registered.
+        exists := make([]*ds.Key, len(components))
+        for i, c := range components {
+                exists[i] = di.KeyForObj(c)
+        }
+        bl, err := di.ExistsMulti(exists)
+        if err != nil {
+                return err
+        }
+
+        // Only create entities that don't already exist.
+        create := make([]*componentEntity, 0, len(components))
+        for i, b := range bl {
+                if !b {
+                        create = append(create, components[i])
+                }
+        }
+
+        if len(create) > 0 {
+                if err := di.PutMulti(create); err != nil {
+                        return err
+                }
+        }
+        return nil
 }
 
 // MarkPurged sets the named path component's purged status to v.
 //
 // MarkPurged will panic if any input data is invalid. It will only fail if
 // datastore operations fail.
 func MarkPurged(di ds.Interface, p types.StreamPath, v bool) error {
         if err := p.Validate(); err != nil {
                 panic(p)
         }
@@ skipping 161 matching lines @@
                 return nil, err
         }
         return &l, nil
 }
 
 // Root returns the datastore key for the hierarchy entity root.
 func Root(di ds.Interface) *ds.Key {
         k, _ := componentTokenKey(di, nil)
         return k
 }