LogDog: Add project support to Storage.

server/logdog/storage/bigtable/rowKey.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 bigtable
 
 import (
         "bytes"
         "crypto/sha256"
         "encoding/base64"
@@ skipping 89 matching lines @@
 // NOTE: There is a "legacy" period of time when row keys will NOT include a
 // count. Since these sort before row keys with a count, row key order will be
 // maintained. These row keys will have a count value of "0".
 type rowKey struct {
         pathHash []byte
         index    int64
         count    int64
 }
 
 // newRowKey generates the row key matching a given entry path and index.
-func newRowKey(path string, index, count int64) *rowKey {
-        pathHash := sha256.Sum256([]byte(path))
+func newRowKey(project, path string, index, count int64) *rowKey {
+        h := sha256.New()
+
+        // TODO(dnj): Remove this conditional when non-project data is aged off.
+        if project != "" {
+                _, _ = h.Write([]byte(project))

[Ryan Tseng, 2016/04/28 21:04:31]

isn't the assignment redundant at this point?

[dnj, 2016/04/30 02:56:49]

Not really. There is actually a tool that will force us to do this for all
return values. I figured I'd get a heads-up.

+                _, _ = h.Write([]byte("/"))
+        }
+
+        _, _ = h.Write([]byte(path))
         return &rowKey{
-                pathHash: pathHash[:],
+                pathHash: h.Sum(nil),
                 index:    index,
                 count:    count,
         }
 }
 
 // decodeRowKey decodes an encoded row key into its structural components.
 func decodeRowKey(v string) (*rowKey, error) {
         keyParts := strings.SplitN(v, "~", 3)
         if len(keyParts) < 2 {
                 // TODO: Make this force 3 once "legacy mode" is disabled.
                 return nil, errMalformedRowKey
         }
 
         hashEnc, idxEnc := keyParts[0], keyParts[1]
         if base64.URLEncoding.DecodedLen(len(hashEnc)) < sha256.Size {
                 return nil, errMalformedRowKey
         }
 
-        // Decode encoded path hash.
+        // Decode encoded project/path hash.
         var err error
         rk := rowKey{}
         rk.pathHash, err = base64.URLEncoding.DecodeString(hashEnc)
         if err != nil {
                 return nil, errMalformedRowKey
         }
 
         // Decode index.
         rk.index, err = readHexInt64(idxEnc)
         if err != nil {
@@ skipping 24 matching lines @@
                 rkb.appendInt64(rk.index)
                 if rk.count > 0 {
                         rkb.appendBytes([]byte("~"))
                         rkb.appendInt64(rk.count)
                 }
                 v = rkb.value()
         })
         return
 }
 
-// prefix returns the encoded path prefix for the row key.
+// prefix returns the encoded path prefix for the row key, which is the hash of
+// that row's project/path.
 func (rk *rowKey) pathPrefix() (v string) {
         withRowKeyBuffers(func(rkb *rowKeyBuffers) {
                 rkb.appendPathPrefix(rk.pathHash)
                 rkb.appendBytes([]byte("~"))
                 v = rkb.value()
         })
         return
 }
 
 // pathPrefixUpperBound returns the path prefix that is higher than any path
@@ skipping 33 matching lines @@
                 return 0, errMalformedRowKey
         }
 
         // There should be no more data.
         if dr.Len() > 0 {
                 return 0, errMalformedRowKey
         }
 
         return value, nil
 }