// Test added after error in getting two paths to the same ancestor k/v after merge.
func TestDiamondGetOnMerge(t *testing.T) {
datastore.OpenTest()
defer datastore.CloseTest()
uuid, _ := initTestRepo()
config := dvid.NewConfig()
dataservice, err := datastore.NewData(uuid, kvtype, "mergetest", config)
if err != nil {
t.Fatalf("Error creating new keyvalue instance: %v\n", err)
}
data, ok := dataservice.(*Data)
if !ok {
t.Fatalf("Returned new data instance is not roi.Data\n")
}
// PUT a value
key1 := "mykey"
value1 := "some stuff"
key1req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid, data.DataName(), key1)
server.TestHTTP(t, "POST", key1req, strings.NewReader(value1))
if err = datastore.Commit(uuid, "my commit msg", []string{"stuff one", "stuff two"}); err != nil {
t.Errorf("Unable to lock root node %s: %v\n", uuid, err)
}
uuid2, err := datastore.NewVersion(uuid, "first child", nil)
if err != nil {
t.Fatalf("Unable to create 1st child off root %s: %v\n", uuid, err)
}
if err = datastore.Commit(uuid2, "first child", nil); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid2, err)
}
uuid3, err := datastore.NewVersion(uuid, "second child", nil)
if err != nil {
t.Fatalf("Unable to create 2nd child off root %s: %v\n", uuid, err)
}
if err = datastore.Commit(uuid3, "second child", nil); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid3, err)
}
child, err := datastore.Merge([]dvid.UUID{uuid2, uuid3}, "merging stuff", datastore.MergeConflictFree)
if err != nil {
t.Errorf("Error doing merge: %v\n", err)
}
// We should be able to see just the original uuid value of the k/v
childreq := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, child, data.DataName(), key1)
returnValue := server.TestHTTP(t, "GET", childreq, nil)
if string(returnValue) != value1 {
t.Errorf("Error on merged child, key %q: expected %q, got %q\n", key1, value1, string(returnValue))
}
}
func repoCommitHandler(c web.C, w http.ResponseWriter, r *http.Request) {
uuid := c.Env["uuid"].(dvid.UUID)
data, err := ioutil.ReadAll(r.Body)
if err != nil {
BadRequest(w, r, err)
return
}
jsonData := struct {
Note string `json:"note"`
Log []string `json:"log"`
}{}
if err := json.Unmarshal(data, &jsonData); err != nil {
BadRequest(w, r, fmt.Sprintf("Malformed JSON request in body: %v", err))
return
}
err = datastore.Commit(uuid, jsonData.Note, jsonData.Log)
if err != nil {
BadRequest(w, r, err)
} else {
w.Header().Set("Content-Type", "text/plain")
fmt.Fprintf(w, "Node %s committed and locked.\n", uuid)
}
}
func TestKeyvalueUnversioned(t *testing.T) {
datastore.OpenTest()
defer datastore.CloseTest()
uuid, _ := initTestRepo()
config := dvid.NewConfig()
config.Set("versioned", "false")
dataservice, err := datastore.NewData(uuid, kvtype, "unversiontest", config)
if err != nil {
t.Fatalf("Error creating new keyvalue instance: %v\n", err)
}
data, ok := dataservice.(*Data)
if !ok {
t.Fatalf("Returned new data instance is not roi.Data\n")
}
// PUT a value
key1 := "mykey"
value1 := "some stuff"
key1req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid, data.DataName(), key1)
server.TestHTTP(t, "POST", key1req, strings.NewReader(value1))
// Add 2nd k/v
key2 := "my2ndkey"
value2 := "more good stuff"
key2req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid, data.DataName(), key2)
server.TestHTTP(t, "POST", key2req, strings.NewReader(value2))
// Create a new version in repo
if err = datastore.Commit(uuid, "my commit msg", []string{"stuff one", "stuff two"}); err != nil {
t.Errorf("Unable to lock root node %s: %v\n", uuid, err)
}
uuid2, err := datastore.NewVersion(uuid, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid, err)
}
_, err = datastore.VersionFromUUID(uuid2)
if err != nil {
t.Fatalf("Unable to get version ID from new uuid %s: %v\n", uuid2, err)
}
// Change the 2nd k/v
uuid2val := "this is completely different"
uuid2req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid2, data.DataName(), key2)
server.TestHTTP(t, "POST", uuid2req, strings.NewReader(uuid2val))
// Now the first version value should equal the new value
returnValue := server.TestHTTP(t, "GET", key2req, nil)
if string(returnValue) != uuid2val {
t.Errorf("Error on unversioned key %q: expected %s, got %s\n", key2, uuid2val, string(returnValue))
}
// Get the second version value
returnValue = server.TestHTTP(t, "GET", uuid2req, nil)
if string(returnValue) != uuid2val {
t.Errorf("Error on unversioned key %q: expected %s, got %s\n", key2, uuid2val, string(returnValue))
}
// Check return of first two keys in range.
rangereq := fmt.Sprintf("%snode/%s/%s/keyrange/%s/%s", server.WebAPIPath, uuid, data.DataName(),
"my", "zebra")
returnValue = server.TestHTTP(t, "GET", rangereq, nil)
var retrievedKeys []string
if err = json.Unmarshal(returnValue, &retrievedKeys); err != nil {
t.Errorf("Bad key range request unmarshal: %v\n", err)
}
if len(retrievedKeys) != 2 || retrievedKeys[1] != "mykey" && retrievedKeys[0] != "my2ndKey" {
t.Errorf("Bad key range request return. Expected: [%q,%q]. Got: %s\n",
key1, key2, string(returnValue))
}
// Commit the repo
if err = datastore.Commit(uuid2, "my 2nd commit msg", []string{"changed 2nd k/v"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid2, err)
}
// Make grandchild of root
uuid3, err := datastore.NewVersion(uuid2, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid2, err)
}
// Delete the 2nd k/v
uuid3req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid3, data.DataName(), key2)
server.TestHTTP(t, "DELETE", uuid3req, nil)
server.TestBadHTTP(t, "GET", uuid3req, nil)
// Make sure the 2nd k/v is now missing for previous versions.
server.TestBadHTTP(t, "GET", key2req, nil)
server.TestBadHTTP(t, "GET", uuid2req, nil)
// Make a child
if err = datastore.Commit(uuid3, "my 3rd commit msg", []string{"deleted 2nd k/v"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid2, err)
}
uuid4, err := datastore.NewVersion(uuid3, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid3, err)
}
// Change the 2nd k/v
uuid4val := "we are reintroducing this k/v"
uuid4req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid4, data.DataName(), key2)
server.TestHTTP(t, "POST", uuid4req, strings.NewReader(uuid4val))
if err = datastore.Commit(uuid4, "commit node 4", []string{"we modified stuff"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid4, err)
}
// Make sure the 2nd k/v is correct for each of previous versions.
returnValue = server.TestHTTP(t, "GET", key2req, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on first version, key %q: expected %s, got %s\n", key2, uuid4val, string(returnValue))
}
returnValue = server.TestHTTP(t, "GET", uuid2req, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on second version, key %q: expected %s, got %s\n", key2, uuid4val, string(returnValue))
}
returnValue = server.TestHTTP(t, "GET", uuid3req, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on third version, key %q: expected %s, got %s\n", key2, uuid4val, string(returnValue))
}
returnValue = server.TestHTTP(t, "GET", uuid4req, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on fourth version, key %q: expected %s, got %s\n", key2, uuid4val, string(returnValue))
}
}
func TestKeyvalueVersioning(t *testing.T) {
datastore.OpenTest()
defer datastore.CloseTest()
uuid, _ := initTestRepo()
config := dvid.NewConfig()
dataservice, err := datastore.NewData(uuid, kvtype, "versiontest", config)
if err != nil {
t.Fatalf("Error creating new keyvalue instance: %v\n", err)
}
data, ok := dataservice.(*Data)
if !ok {
t.Fatalf("Returned new data instance is not roi.Data\n")
}
// PUT a value
key1 := "mykey"
value1 := "some stuff"
key1req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid, data.DataName(), key1)
server.TestHTTP(t, "POST", key1req, strings.NewReader(value1))
// Add 2nd k/v
key2 := "my2ndkey"
value2 := "more good stuff"
key2req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid, data.DataName(), key2)
server.TestHTTP(t, "POST", key2req, strings.NewReader(value2))
// Create a new version in repo
if err = datastore.Commit(uuid, "my commit msg", []string{"stuff one", "stuff two"}); err != nil {
t.Errorf("Unable to lock root node %s: %v\n", uuid, err)
}
uuid2, err := datastore.NewVersion(uuid, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid, err)
}
_, err = datastore.VersionFromUUID(uuid2)
if err != nil {
t.Fatalf("Unable to get version ID from new uuid %s: %v\n", uuid2, err)
}
// Change the 2nd k/v
uuid2val := "this is completely different"
uuid2req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid2, data.DataName(), key2)
server.TestHTTP(t, "POST", uuid2req, strings.NewReader(uuid2val))
// Get the first version value
returnValue := server.TestHTTP(t, "GET", key2req, nil)
if string(returnValue) != value2 {
t.Errorf("Error on first version, key %q: expected %s, got %s\n", key2, value2, string(returnValue))
}
// Get the second version value
returnValue = server.TestHTTP(t, "GET", uuid2req, nil)
if string(returnValue) != uuid2val {
t.Errorf("Error on second version, key %q: expected %s, got %s\n", key2, uuid2val, string(returnValue))
}
// Check return of first two keys in range.
rangereq := fmt.Sprintf("%snode/%s/%s/keyrange/%s/%s", server.WebAPIPath, uuid, data.DataName(),
"my", "zebra")
returnValue = server.TestHTTP(t, "GET", rangereq, nil)
var retrievedKeys []string
if err = json.Unmarshal(returnValue, &retrievedKeys); err != nil {
t.Errorf("Bad key range request unmarshal: %v\n", err)
}
if len(retrievedKeys) != 2 || retrievedKeys[1] != "mykey" && retrievedKeys[0] != "my2ndKey" {
t.Errorf("Bad key range request return. Expected: [%q,%q]. Got: %s\n",
key1, key2, string(returnValue))
}
// Commit the repo
if err = datastore.Commit(uuid2, "my 2nd commit msg", []string{"changed 2nd k/v"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid2, err)
}
// Make grandchild of root
uuid3, err := datastore.NewVersion(uuid2, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid2, err)
}
// Delete the 2nd k/v
uuid3req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid3, data.DataName(), key2)
server.TestHTTP(t, "DELETE", uuid3req, nil)
server.TestBadHTTP(t, "GET", uuid3req, nil)
// Make sure the 2nd k/v is correct for each of previous versions.
returnValue = server.TestHTTP(t, "GET", key2req, nil)
if string(returnValue) != value2 {
t.Errorf("Error on first version, key %q: expected %s, got %s\n", key2, value2, string(returnValue))
}
returnValue = server.TestHTTP(t, "GET", uuid2req, nil)
if string(returnValue) != uuid2val {
t.Errorf("Error on second version, key %q: expected %s, got %s\n", key2, uuid2val, string(returnValue))
}
// Make a child
if err = datastore.Commit(uuid3, "my 3rd commit msg", []string{"deleted 2nd k/v"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid2, err)
}
uuid4, err := datastore.NewVersion(uuid3, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid3, err)
}
// Change the 2nd k/v
uuid4val := "we are reintroducing this k/v"
uuid4req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid4, data.DataName(), key2)
server.TestHTTP(t, "POST", uuid4req, strings.NewReader(uuid4val))
if err = datastore.Commit(uuid4, "commit node 4", []string{"we modified stuff"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid4, err)
}
// Make sure the 2nd k/v is correct for each of previous versions.
returnValue = server.TestHTTP(t, "GET", key2req, nil)
if string(returnValue) != value2 {
t.Errorf("Error on first version, key %q: expected %s, got %s\n", key2, value2, string(returnValue))
}
returnValue = server.TestHTTP(t, "GET", uuid2req, nil)
if string(returnValue) != uuid2val {
t.Errorf("Error on second version, key %q: expected %s, got %s\n", key2, uuid2val, string(returnValue))
}
server.TestBadHTTP(t, "GET", uuid3req, nil)
returnValue = server.TestHTTP(t, "GET", uuid4req, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on fourth version, key %q: expected %s, got %s\n", key2, uuid4val, string(returnValue))
}
// Let's try a merge!
// Make a child off the 2nd version from root.
uuid5, err := datastore.NewVersion(uuid2, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid2, err)
}
// Store new stuff in 2nd k/v
uuid5val := "this is forked value"
uuid5req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid5, data.DataName(), key2)
server.TestHTTP(t, "POST", uuid5req, strings.NewReader(uuid5val))
returnValue = server.TestHTTP(t, "GET", uuid5req, nil)
if string(returnValue) != uuid5val {
t.Errorf("Error on merged child, key %q: expected %q, got %q\n", key2, uuid5val, string(returnValue))
}
// Commit node
if err = datastore.Commit(uuid5, "forked node", []string{"we modified stuff"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid5, err)
}
// Should be able to merge using conflict-free (disjoint at key level) merge even though
// its conflicted. Will get lazy error on request.
badChild, err := datastore.Merge([]dvid.UUID{uuid4, uuid5}, "some child", datastore.MergeConflictFree)
if err != nil {
t.Errorf("Error doing merge: %v\n", err)
}
childreq := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, badChild, data.DataName(), key2)
server.TestBadHTTP(t, "GET", childreq, nil)
// Manually fix conflict: Branch, and then delete 2nd k/v and commit.
uuid6, err := datastore.NewVersion(uuid5, "some child", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid5, err)
}
uuid6req := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, uuid6, data.DataName(), key2)
server.TestHTTP(t, "DELETE", uuid6req, nil)
server.TestBadHTTP(t, "GET", uuid6req, nil)
if err = datastore.Commit(uuid6, "deleted forked node 2nd k/v", []string{"we modified stuff"}); err != nil {
t.Errorf("Unable to commit node %s: %s\n", uuid6, err)
}
// Should now be able to correctly merge the two branches.
goodChild, err := datastore.Merge([]dvid.UUID{uuid4, uuid6}, "merging stuff", datastore.MergeConflictFree)
if err != nil {
t.Errorf("Error doing merge: %v\n", err)
}
// We should be able to see just the original uuid4 value of the 2nd k/v
childreq = fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, goodChild, data.DataName(), key2)
returnValue = server.TestHTTP(t, "GET", childreq, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on merged child, key %q: expected %q, got %q\n", key2, uuid4val, string(returnValue))
}
// Apply the automatic conflict resolution using ordering.
payload := fmt.Sprintf(`{"data":["versiontest"],"parents":[%q,%q],"note":"automatic resolved merge"}`, uuid5, uuid4)
resolveReq := fmt.Sprintf("%srepo/%s/resolve", server.WebAPIPath, uuid4)
returnValue = server.TestHTTP(t, "POST", resolveReq, bytes.NewBufferString(payload))
resolveResp := struct {
Child dvid.UUID `json:"child"`
}{}
if err := json.Unmarshal(returnValue, &resolveResp); err != nil {
t.Fatalf("Can't parse return of resolve request: %s\n", string(returnValue))
}
// We should now see the uuid5 version of the 2nd k/v in the returned merged node.
childreq = fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, resolveResp.Child, data.DataName(), key2)
returnValue = server.TestHTTP(t, "GET", childreq, nil)
if string(returnValue) != uuid5val {
t.Errorf("Error on auto merged child, key %q: expected %q, got %q\n", key2, uuid5val, string(returnValue))
}
// Introduce a child off root but don't add 2nd k/v to it.
uuid7, err := datastore.NewVersion(uuid, "2nd child off root", nil)
if err != nil {
t.Fatalf("Unable to create new version off node %s: %v\n", uuid, err)
}
if err = datastore.Commit(uuid7, "useless node", []string{"we modified nothing!"}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", uuid7, err)
}
// Now merge the previously merged node with the newly created "blank" child off root.
if err = datastore.Commit(goodChild, "this was a good merge", []string{}); err != nil {
t.Errorf("Unable to commit node %s: %v\n", goodChild, err)
}
merge2, err := datastore.Merge([]dvid.UUID{goodChild, uuid7}, "merging a useless path", datastore.MergeConflictFree)
if err != nil {
t.Errorf("Error doing merge: %v\n", err)
}
merge3, err := datastore.Merge([]dvid.UUID{uuid7, goodChild}, "merging a useless path in reverse order", datastore.MergeConflictFree)
if err != nil {
t.Errorf("Error doing merge: %v\n", err)
}
// We should still be conflict free since 2nd key in left parent path will take precedent over shared 2nd key
// in root. This tests our invalidation of ancestors.
toughreq := fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, merge2, data.DataName(), key2)
returnValue = server.TestHTTP(t, "GET", toughreq, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on merged child, key %q: expected %q, got %q\n", key2, uuid4val, string(returnValue))
}
toughreq = fmt.Sprintf("%snode/%s/%s/key/%s", server.WebAPIPath, merge3, data.DataName(), key2)
returnValue = server.TestHTTP(t, "GET", toughreq, nil)
if string(returnValue) != uuid4val {
t.Errorf("Error on merged child, key %q: expected %q, got %q\n", key2, uuid4val, string(returnValue))
}
}
func repoResolveHandler(c web.C, w http.ResponseWriter, r *http.Request) {
uuid, _, err := datastore.MatchingUUID(c.URLParams["uuid"])
if err != nil {
BadRequest(w, r, err)
return
}
if r.Body == nil {
BadRequest(w, r, "merge resolving requires JSON to be POSTed per API documentation")
return
}
data, err := ioutil.ReadAll(r.Body)
if err != nil {
BadRequest(w, r, err)
return
}
jsonData := struct {
Data []dvid.InstanceName `json:"data"`
Note string `json:"note"`
Parents []string `json:"parents"`
}{}
if err := json.Unmarshal(data, &jsonData); err != nil {
BadRequest(w, r, fmt.Sprintf("Malformed JSON request in body: %v", err))
return
}
if len(jsonData.Data) == 0 {
BadRequest(w, r, "Must specify at least one data instance using 'data' field")
return
}
if len(jsonData.Parents) < 2 {
BadRequest(w, r, "Must specify at least two parent UUIDs using 'parents' field")
return
}
// Convert JSON of parents into []UUID and whether we need a child for them to add deletions.
numParents := len(jsonData.Parents)
oldParents := make([]dvid.UUID, numParents)
newParents := make([]dvid.UUID, numParents, numParents) // UUID of any parent extension for deletions.
for i, uuidFrag := range jsonData.Parents {
uuid, _, err := datastore.MatchingUUID(uuidFrag)
if err != nil {
BadRequest(w, r, fmt.Sprintf("can't match parent %q: %v", uuidFrag, err))
return
}
oldParents[i] = uuid
newParents[i] = dvid.NilUUID
}
// Iterate through all k/v for given data instances, making sure we find any conflicts.
// If any are found, remove them with first UUIDs taking priority.
for _, name := range jsonData.Data {
data, err := datastore.GetDataByUUIDName(uuid, name)
if err != nil {
BadRequest(w, r, err)
return
}
if err := datastore.DeleteConflicts(uuid, data, oldParents, newParents); err != nil {
BadRequest(w, r, fmt.Errorf("Conflict deletion error for data %q: %v", data.DataName(), err))
return
}
}
// If we have any new nodes to accomodate deletions, commit them.
for i, oldUUID := range oldParents {
if newParents[i] != oldUUID {
err := datastore.Commit(newParents[i], "Version for deleting conflicts before merge", nil)
if err != nil {
BadRequest(w, r, "Error while creating new nodes to handle required deletions: %v", err)
return
}
}
}
// Do the merge
mt := datastore.MergeConflictFree
newuuid, err := datastore.Merge(newParents, jsonData.Note, mt)
if err != nil {
BadRequest(w, r, err)
} else {
w.Header().Set("Content-Type", "application/json")
fmt.Fprintf(w, "{%q: %q}", "child", newuuid)
}
}
