Merge branch '7167-keep-rsync-test-setup' into 7167-keep-rsync

Conflicts:
	tools/keep-rsync/keep-rsync_test.go

diff --cc tools/keep-rsync/keep-rsync.go
Simple merge

diff --cc tools/keep-rsync/keep-rsync_test.go
index 87cc0f5868e58bde6d882ac719db1d339ccaf5de,c2a8112dc5c9d93a5489dd82df48a0d451fa8367..5cfd30a0328dec845dd3026718bdf13f98fa52f8
--- 1/tools/keep-rsync/keep-rsync_test.go
--- 2/tools/keep-rsync/keep-rsync_test.go
+++ b/tools/keep-rsync/keep-rsync_test.go
@@@ -167,85 -173,56 +173,139 @@@ func (s *ServerRequiredSuite) TestRsync
        c.Check(foundIt, Equals, true)
  }
  
-       setupRsync(c)
+ // Test keep-rsync initialization, with src and dst keep servers with blobSingingKey.
+ // Do a Put and Get in src, both of which should succeed.
+ // Do a Put and Get in dst, both of which should succeed.
+ // Do a Get in dst for the src hash, which should raise block not found error.
+ // Do a Get in src for the dst hash, which should raise block not found error.
+ func (s *ServerRequiredSuite) TestRsyncWithBlobSigning_PutInOne_GetFromOtherShouldFail(c *C) {
+       setupRsync(c, true)
+ 
+       // Put a block in src using kcSrc and Get it
+       srcData := []byte("test-data1")
+       locatorInSrc := fmt.Sprintf("%x", md5.Sum(srcData))
+ 
+       hash, rep, err := kcSrc.PutB(srcData)
+       c.Check(hash, Matches, fmt.Sprintf(`^%s\+10(\+.+)?$`, locatorInSrc))
+       c.Check(rep, Equals, 2)
+       c.Check(err, Equals, nil)
+ 
+       tomorrow := time.Now().AddDate(0, 0, 1)
+       signedLocator := keepclient.SignLocator(locatorInSrc, arvSrc.ApiToken, tomorrow, []byte(blobSigningKey))
+ 
+       reader, blocklen, _, err := kcSrc.Get(signedLocator)
+       c.Assert(err, Equals, nil)
+       c.Check(blocklen, Equals, int64(10))
+       all, err := ioutil.ReadAll(reader)
+       c.Check(all, DeepEquals, srcData)
+ 
+       // Put a different block in src using kcSrc and Get it
+       dstData := []byte("test-data2")
+       locatorInDst := fmt.Sprintf("%x", md5.Sum(dstData))
+ 
+       hash, rep, err = kcDst.PutB(dstData)
+       c.Check(hash, Matches, fmt.Sprintf(`^%s\+10(\+.+)?$`, locatorInDst))
+       c.Check(rep, Equals, 1)
+       c.Check(err, Equals, nil)
+ 
+       signedLocator = keepclient.SignLocator(locatorInDst, arvDst.ApiToken, tomorrow, []byte(blobSigningKey))
+ 
+       reader, blocklen, _, err = kcDst.Get(signedLocator)
+       c.Assert(err, Equals, nil)
+       c.Check(blocklen, Equals, int64(10))
+       all, err = ioutil.ReadAll(reader)
+       c.Check(all, DeepEquals, dstData)
+ 
+       // Get srcLocator using kcDst should fail with NotFound error
+       signedLocator = keepclient.SignLocator(locatorInSrc, arvDst.ApiToken, tomorrow, []byte(blobSigningKey))
+       _, _, _, err = kcDst.Get(locatorInSrc)
+       c.Assert(err.Error(), Equals, "Block not found")
+ 
+       // Get dstLocator using kcSrc should fail with NotFound error
+       signedLocator = keepclient.SignLocator(locatorInDst, arvSrc.ApiToken, tomorrow, []byte(blobSigningKey))
+       _, _, _, err = kcSrc.Get(locatorInDst)
+       c.Assert(err.Error(), Equals, "Block not found")
+ }
++
 +// Put 5 blocks in src. Put 2 of those blocks in dst
 +// Hence there are 3 additional blocks in src
 +// Also, put 2 extra blocks in dts; they are hence only in dst
 +// Run rsync and verify that those 7 blocks are now available in dst
 +func (s *ServerRequiredSuite) TestKeepRsync(c *C) {
++      setupRsync(c, false)
 +
 +      // Put a few blocks in src using kcSrc
 +      var srcLocators []string
 +      for i := 0; i < 5; i++ {
 +              data := []byte(fmt.Sprintf("test-data-%d", i))
 +              hash := fmt.Sprintf("%x", md5.Sum(data))
 +
 +              hash2, rep, err := kcSrc.PutB(data)
 +              c.Check(hash2, Matches, fmt.Sprintf(`^%s\+11(\+.+)?$`, hash))
 +              c.Check(rep, Equals, 2)
 +              c.Check(err, Equals, nil)
 +
 +              reader, blocklen, _, err := kcSrc.Get(hash)
 +              c.Assert(err, Equals, nil)
 +              c.Check(blocklen, Equals, int64(11))
 +              all, err := ioutil.ReadAll(reader)
 +              c.Check(all, DeepEquals, data)
 +
 +              srcLocators = append(srcLocators, fmt.Sprintf("%s+%d", hash, blocklen))
 +      }
 +
 +      // Put just two of those blocks in dst using kcDst
 +      var dstLocators []string
 +      for i := 0; i < 2; i++ {
 +              data := []byte(fmt.Sprintf("test-data-%d", i))
 +              hash := fmt.Sprintf("%x", md5.Sum(data))
 +
 +              hash2, rep, err := kcDst.PutB(data)
 +              c.Check(hash2, Matches, fmt.Sprintf(`^%s\+11(\+.+)?$`, hash))
 +              c.Check(rep, Equals, 1)
 +              c.Check(err, Equals, nil)
 +
 +              reader, blocklen, _, err := kcDst.Get(hash)
 +              c.Assert(err, Equals, nil)
 +              c.Check(blocklen, Equals, int64(11))
 +              all, err := ioutil.ReadAll(reader)
 +              c.Check(all, DeepEquals, data)
 +
 +              dstLocators = append(dstLocators, fmt.Sprintf("%s+%d", hash, blocklen))
 +      }
 +
 +      // Put two more blocks in dst; they are not in src at all
 +      var extraDstLocators []string
 +      for i := 0; i < 2; i++ {
 +              data := []byte(fmt.Sprintf("other-data-%d", i))
 +              hash := fmt.Sprintf("%x", md5.Sum(data))
 +
 +              hash2, rep, err := kcDst.PutB(data)
 +              c.Check(hash2, Matches, fmt.Sprintf(`^%s\+12(\+.+)?$`, hash))
 +              c.Check(rep, Equals, 1)
 +              c.Check(err, Equals, nil)
 +
 +              reader, blocklen, _, err := kcDst.Get(hash)
 +              c.Assert(err, Equals, nil)
 +              c.Check(blocklen, Equals, int64(12))
 +              all, err := ioutil.ReadAll(reader)
 +              c.Check(all, DeepEquals, data)
 +
 +              extraDstLocators = append(extraDstLocators, fmt.Sprintf("%s+%d", hash, blocklen))
 +      }
 +
 +      err := performKeepRsync()
 +      c.Check(err, Equals, nil)
 +
 +      // Now GetIndex from dst and verify that all 5 from src and the 2 extra blocks are found
 +      dstIndex, err := getUniqueLocators(kcDst, "")
 +      c.Check(err, Equals, nil)
 +      for _, locator := range srcLocators {
 +              _, ok := dstIndex[locator]
 +              c.Assert(ok, Equals, true)
 +      }
 +      for _, locator := range extraDstLocators {
 +              _, ok := dstIndex[locator]
 +              c.Assert(ok, Equals, true)
 +      }
 +}