// CreateTwoWayMergePatch creates a patch that can be passed to StrategicMergePatch from an original // document and a modified document, which are passed to the method as json encoded content. It will // return a patch that yields the modified document when applied to the original document, or an error // if either of the two documents is invalid. func CreateTwoWayMergePatch(original, modified []byte, dataStruct interface{}, fns ...PreconditionFunc) ([]byte, error) { originalMap := map[string]interface{}{} if len(original) > 0 { if err := json.Unmarshal(original, &originalMap); err != nil { return nil, errBadJSONDoc } } modifiedMap := map[string]interface{}{} if len(modified) > 0 { if err := json.Unmarshal(modified, &modifiedMap); err != nil { return nil, errBadJSONDoc } } t, err := getTagStructType(dataStruct) if err != nil { return nil, err } patchMap, err := diffMaps(originalMap, modifiedMap, t, false, false) if err != nil { return nil, err } // Apply the preconditions to the patch, and return an error if any of them fail. for _, fn := range fns { if !fn(patchMap) { return nil, newErrPreconditionFailed(patchMap) } } return json.Marshal(patchMap) }
// StrategicMergePatch applies a strategic merge patch. The patch and the original document // must be json encoded content. A patch can be created from an original and a modified document // by calling CreateStrategicMergePatch. func StrategicMergePatch(original, patch []byte, dataStruct interface{}) ([]byte, error) { if original == nil { original = []byte("{}") } if patch == nil { patch = []byte("{}") } originalMap := map[string]interface{}{} err := json.Unmarshal(original, &originalMap) if err != nil { return nil, errBadJSONDoc } patchMap := map[string]interface{}{} err = json.Unmarshal(patch, &patchMap) if err != nil { return nil, errBadJSONDoc } t, err := getTagStructType(dataStruct) if err != nil { return nil, err } result, err := mergeMap(originalMap, patchMap, t) if err != nil { return nil, err } return json.Marshal(result) }
// test the processItem function making the expected actions. func TestProcessItem(t *testing.T) { pod := newDanglingPod() podBytes, err := json.Marshal(pod) if err != nil { t.Fatal(err) } testHandler := &fakeActionHandler{ response: map[string]FakeResponse{ "GET" + "/api/v1/namespaces/ns1/replicationcontrollers/owner1": { 404, []byte{}, }, "GET" + "/api/v1/namespaces/ns1/pods/ToBeDeletedPod": { 200, podBytes, }, }, } podResource := []unversioned.GroupVersionResource{{Version: "v1", Resource: "pods"}} srv, clientConfig := testServerAndClientConfig(testHandler.ServeHTTP) defer srv.Close() clientPool := dynamic.NewClientPool(clientConfig, dynamic.LegacyAPIPathResolverFunc) gc, err := NewGarbageCollector(clientPool, podResource) if err != nil { t.Fatal(err) } item := &node{ identity: objectReference{ OwnerReference: metatypes.OwnerReference{ Kind: pod.Kind, APIVersion: pod.APIVersion, Name: pod.Name, UID: pod.UID, }, Namespace: pod.Namespace, }, // owners are intentionally left empty. The processItem routine should get the latest item from the server. owners: nil, } err = gc.processItem(item) if err != nil { t.Errorf("Unexpected Error: %v", err) } expectedActionSet := sets.NewString() expectedActionSet.Insert("GET=/api/v1/namespaces/ns1/replicationcontrollers/owner1") expectedActionSet.Insert("DELETE=/api/v1/namespaces/ns1/pods/ToBeDeletedPod") expectedActionSet.Insert("GET=/api/v1/namespaces/ns1/pods/ToBeDeletedPod") actualActionSet := sets.NewString() for _, action := range testHandler.actions { actualActionSet.Insert(action.String()) } if !expectedActionSet.Equal(actualActionSet) { t.Errorf("expected actions:\n%v\n but got:\n%v\nDifference:\n%v", expectedActionSet, actualActionSet, expectedActionSet.Difference(actualActionSet)) } }
// This function takes a JSON map and sorts all the lists that should be merged // by key. This is needed by tests because in JSON, list order is significant, // but in Strategic Merge Patch, merge lists do not have significant order. // Sorting the lists allows for order-insensitive comparison of patched maps. func sortMergeListsByName(mapJSON []byte, dataStruct interface{}) ([]byte, error) { var m map[string]interface{} err := json.Unmarshal(mapJSON, &m) if err != nil { return nil, err } newM, err := sortMergeListsByNameMap(m, reflect.TypeOf(dataStruct)) if err != nil { return nil, err } return json.Marshal(newM) }
// CreateThreeWayMergePatch reconciles a modified configuration with an original configuration, // while preserving any changes or deletions made to the original configuration in the interim, // and not overridden by the current configuration. All three documents must be passed to the // method as json encoded content. It will return a strategic merge patch, or an error if any // of the documents is invalid, or if there are any preconditions that fail against the modified // configuration, or, if overwrite is false and there are conflicts between the modified and current // configurations. Conflicts are defined as keys changed differently from original to modified // than from original to current. In other words, a conflict occurs if modified changes any key // in a way that is different from how it is changed in current (e.g., deleting it, changing its // value). func CreateThreeWayMergePatch(original, modified, current []byte, dataStruct interface{}, overwrite bool, fns ...PreconditionFunc) ([]byte, error) { originalMap := map[string]interface{}{} if len(original) > 0 { if err := json.Unmarshal(original, &originalMap); err != nil { return nil, errBadJSONDoc } } modifiedMap := map[string]interface{}{} if len(modified) > 0 { if err := json.Unmarshal(modified, &modifiedMap); err != nil { return nil, errBadJSONDoc } } currentMap := map[string]interface{}{} if len(current) > 0 { if err := json.Unmarshal(current, ¤tMap); err != nil { return nil, errBadJSONDoc } } t, err := getTagStructType(dataStruct) if err != nil { return nil, err } // The patch is the difference from current to modified without deletions, plus deletions // from original to modified. To find it, we compute deletions, which are the deletions from // original to modified, and delta, which is the difference from current to modified without // deletions, and then apply delta to deletions as a patch, which should be strictly additive. deltaMap, err := diffMaps(currentMap, modifiedMap, t, false, true) if err != nil { return nil, err } deletionsMap, err := diffMaps(originalMap, modifiedMap, t, true, false) if err != nil { return nil, err } patchMap, err := mergeMap(deletionsMap, deltaMap, t) if err != nil { return nil, err } // Apply the preconditions to the patch, and return an error if any of them fail. for _, fn := range fns { if !fn(patchMap) { return nil, newErrPreconditionFailed(patchMap) } } // If overwrite is false, and the patch contains any keys that were changed differently, // then return a conflict error. if !overwrite { changedMap, err := diffMaps(originalMap, currentMap, t, false, false) if err != nil { return nil, err } hasConflicts, err := MergingMapsHaveConflicts(patchMap, changedMap, dataStruct) if err != nil { return nil, err } if hasConflicts { return nil, newErrConflict(toYAMLOrError(patchMap), toYAMLOrError(changedMap)) } } return json.Marshal(patchMap) }