mirror of
https://github.com/ceph/ceph-csi.git
synced 2024-11-09 16:00:22 +00:00
5af3fe5deb
this commits add the controller runtime and its dependency to the vendor. Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>
337 lines
8.1 KiB
Go
337 lines
8.1 KiB
Go
package jsonpatch
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
)
|
|
|
|
var errBadJSONDoc = fmt.Errorf("invalid JSON Document")
|
|
|
|
type JsonPatchOperation = Operation
|
|
|
|
type Operation struct {
|
|
Operation string `json:"op"`
|
|
Path string `json:"path"`
|
|
Value interface{} `json:"value,omitempty"`
|
|
}
|
|
|
|
func (j *Operation) Json() string {
|
|
b, _ := json.Marshal(j)
|
|
return string(b)
|
|
}
|
|
|
|
func (j *Operation) MarshalJSON() ([]byte, error) {
|
|
var b bytes.Buffer
|
|
b.WriteString("{")
|
|
b.WriteString(fmt.Sprintf(`"op":"%s"`, j.Operation))
|
|
b.WriteString(fmt.Sprintf(`,"path":"%s"`, j.Path))
|
|
// Consider omitting Value for non-nullable operations.
|
|
if j.Value != nil || j.Operation == "replace" || j.Operation == "add" {
|
|
v, err := json.Marshal(j.Value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b.WriteString(`,"value":`)
|
|
b.Write(v)
|
|
}
|
|
b.WriteString("}")
|
|
return b.Bytes(), nil
|
|
}
|
|
|
|
type ByPath []Operation
|
|
|
|
func (a ByPath) Len() int { return len(a) }
|
|
func (a ByPath) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
func (a ByPath) Less(i, j int) bool { return a[i].Path < a[j].Path }
|
|
|
|
func NewPatch(operation, path string, value interface{}) Operation {
|
|
return Operation{Operation: operation, Path: path, Value: value}
|
|
}
|
|
|
|
// CreatePatch creates a patch as specified in http://jsonpatch.com/
|
|
//
|
|
// 'a' is original, 'b' is the modified document. Both are to be given as json encoded content.
|
|
// The function will return an array of JsonPatchOperations
|
|
//
|
|
// An error will be returned if any of the two documents are invalid.
|
|
func CreatePatch(a, b []byte) ([]Operation, error) {
|
|
var aI interface{}
|
|
var bI interface{}
|
|
err := json.Unmarshal(a, &aI)
|
|
if err != nil {
|
|
return nil, errBadJSONDoc
|
|
}
|
|
err = json.Unmarshal(b, &bI)
|
|
if err != nil {
|
|
return nil, errBadJSONDoc
|
|
}
|
|
return handleValues(aI, bI, "", []Operation{})
|
|
}
|
|
|
|
// Returns true if the values matches (must be json types)
|
|
// The types of the values must match, otherwise it will always return false
|
|
// If two map[string]interface{} are given, all elements must match.
|
|
func matchesValue(av, bv interface{}) bool {
|
|
if reflect.TypeOf(av) != reflect.TypeOf(bv) {
|
|
return false
|
|
}
|
|
switch at := av.(type) {
|
|
case string:
|
|
bt, ok := bv.(string)
|
|
if ok && bt == at {
|
|
return true
|
|
}
|
|
case float64:
|
|
bt, ok := bv.(float64)
|
|
if ok && bt == at {
|
|
return true
|
|
}
|
|
case bool:
|
|
bt, ok := bv.(bool)
|
|
if ok && bt == at {
|
|
return true
|
|
}
|
|
case map[string]interface{}:
|
|
bt, ok := bv.(map[string]interface{})
|
|
if !ok {
|
|
return false
|
|
}
|
|
for key := range at {
|
|
if !matchesValue(at[key], bt[key]) {
|
|
return false
|
|
}
|
|
}
|
|
for key := range bt {
|
|
if !matchesValue(at[key], bt[key]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
case []interface{}:
|
|
bt, ok := bv.([]interface{})
|
|
if !ok {
|
|
return false
|
|
}
|
|
if len(bt) != len(at) {
|
|
return false
|
|
}
|
|
for key := range at {
|
|
if !matchesValue(at[key], bt[key]) {
|
|
return false
|
|
}
|
|
}
|
|
for key := range bt {
|
|
if !matchesValue(at[key], bt[key]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// From http://tools.ietf.org/html/rfc6901#section-4 :
|
|
//
|
|
// Evaluation of each reference token begins by decoding any escaped
|
|
// character sequence. This is performed by first transforming any
|
|
// occurrence of the sequence '~1' to '/', and then transforming any
|
|
// occurrence of the sequence '~0' to '~'.
|
|
// TODO decode support:
|
|
// var rfc6901Decoder = strings.NewReplacer("~1", "/", "~0", "~")
|
|
|
|
var rfc6901Encoder = strings.NewReplacer("~", "~0", "/", "~1")
|
|
|
|
func makePath(path string, newPart interface{}) string {
|
|
key := rfc6901Encoder.Replace(fmt.Sprintf("%v", newPart))
|
|
if path == "" {
|
|
return "/" + key
|
|
}
|
|
if strings.HasSuffix(path, "/") {
|
|
return path + key
|
|
}
|
|
return path + "/" + key
|
|
}
|
|
|
|
// diff returns the (recursive) difference between a and b as an array of JsonPatchOperations.
|
|
func diff(a, b map[string]interface{}, path string, patch []Operation) ([]Operation, error) {
|
|
for key, bv := range b {
|
|
p := makePath(path, key)
|
|
av, ok := a[key]
|
|
// value was added
|
|
if !ok {
|
|
patch = append(patch, NewPatch("add", p, bv))
|
|
continue
|
|
}
|
|
// Types are the same, compare values
|
|
var err error
|
|
patch, err = handleValues(av, bv, p, patch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
// Now add all deleted values as nil
|
|
for key := range a {
|
|
_, found := b[key]
|
|
if !found {
|
|
p := makePath(path, key)
|
|
|
|
patch = append(patch, NewPatch("remove", p, nil))
|
|
}
|
|
}
|
|
return patch, nil
|
|
}
|
|
|
|
func handleValues(av, bv interface{}, p string, patch []Operation) ([]Operation, error) {
|
|
{
|
|
at := reflect.TypeOf(av)
|
|
bt := reflect.TypeOf(bv)
|
|
if at == nil && bt == nil {
|
|
// do nothing
|
|
return patch, nil
|
|
} else if at == nil && bt != nil {
|
|
return append(patch, NewPatch("add", p, bv)), nil
|
|
} else if at != bt {
|
|
// If types have changed, replace completely (preserves null in destination)
|
|
return append(patch, NewPatch("replace", p, bv)), nil
|
|
}
|
|
}
|
|
|
|
var err error
|
|
switch at := av.(type) {
|
|
case map[string]interface{}:
|
|
bt := bv.(map[string]interface{})
|
|
patch, err = diff(at, bt, p, patch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
case string, float64, bool:
|
|
if !matchesValue(av, bv) {
|
|
patch = append(patch, NewPatch("replace", p, bv))
|
|
}
|
|
case []interface{}:
|
|
bt := bv.([]interface{})
|
|
if isSimpleArray(at) && isSimpleArray(bt) {
|
|
patch = append(patch, compareEditDistance(at, bt, p)...)
|
|
} else {
|
|
n := min(len(at), len(bt))
|
|
for i := len(at) - 1; i >= n; i-- {
|
|
patch = append(patch, NewPatch("remove", makePath(p, i), nil))
|
|
}
|
|
for i := n; i < len(bt); i++ {
|
|
patch = append(patch, NewPatch("add", makePath(p, i), bt[i]))
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
var err error
|
|
patch, err = handleValues(at[i], bt[i], makePath(p, i), patch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
panic(fmt.Sprintf("Unknown type:%T ", av))
|
|
}
|
|
return patch, nil
|
|
}
|
|
|
|
func isBasicType(a interface{}) bool {
|
|
switch a.(type) {
|
|
case string, float64, bool:
|
|
default:
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func isSimpleArray(a []interface{}) bool {
|
|
for i := range a {
|
|
switch a[i].(type) {
|
|
case string, float64, bool:
|
|
default:
|
|
val := reflect.ValueOf(a[i])
|
|
if val.Kind() == reflect.Map {
|
|
for _, k := range val.MapKeys() {
|
|
av := val.MapIndex(k)
|
|
if av.Kind() == reflect.Ptr || av.Kind() == reflect.Interface {
|
|
if av.IsNil() {
|
|
continue
|
|
}
|
|
av = av.Elem()
|
|
}
|
|
if av.Kind() != reflect.String && av.Kind() != reflect.Float64 && av.Kind() != reflect.Bool {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm
|
|
// Adapted from https://github.com/texttheater/golang-levenshtein
|
|
func compareEditDistance(s, t []interface{}, p string) []Operation {
|
|
m := len(s)
|
|
n := len(t)
|
|
|
|
d := make([][]int, m+1)
|
|
for i := 0; i <= m; i++ {
|
|
d[i] = make([]int, n+1)
|
|
d[i][0] = i
|
|
}
|
|
for j := 0; j <= n; j++ {
|
|
d[0][j] = j
|
|
}
|
|
|
|
for j := 1; j <= n; j++ {
|
|
for i := 1; i <= m; i++ {
|
|
if reflect.DeepEqual(s[i-1], t[j-1]) {
|
|
d[i][j] = d[i-1][j-1] // no op required
|
|
} else {
|
|
del := d[i-1][j] + 1
|
|
add := d[i][j-1] + 1
|
|
rep := d[i-1][j-1] + 1
|
|
d[i][j] = min(rep, min(add, del))
|
|
}
|
|
}
|
|
}
|
|
|
|
return backtrace(s, t, p, m, n, d)
|
|
}
|
|
|
|
func min(x int, y int) int {
|
|
if y < x {
|
|
return y
|
|
}
|
|
return x
|
|
}
|
|
|
|
func backtrace(s, t []interface{}, p string, i int, j int, matrix [][]int) []Operation {
|
|
if i > 0 && matrix[i-1][j]+1 == matrix[i][j] {
|
|
op := NewPatch("remove", makePath(p, i-1), nil)
|
|
return append([]Operation{op}, backtrace(s, t, p, i-1, j, matrix)...)
|
|
}
|
|
if j > 0 && matrix[i][j-1]+1 == matrix[i][j] {
|
|
op := NewPatch("add", makePath(p, i), t[j-1])
|
|
return append([]Operation{op}, backtrace(s, t, p, i, j-1, matrix)...)
|
|
}
|
|
if i > 0 && j > 0 && matrix[i-1][j-1]+1 == matrix[i][j] {
|
|
if isBasicType(s[0]) {
|
|
op := NewPatch("replace", makePath(p, i-1), t[j-1])
|
|
return append([]Operation{op}, backtrace(s, t, p, i-1, j-1, matrix)...)
|
|
}
|
|
|
|
p2, _ := handleValues(s[i-1], t[j-1], makePath(p, i-1), []Operation{})
|
|
return append(p2, backtrace(s, t, p, i-1, j-1, matrix)...)
|
|
}
|
|
if i > 0 && j > 0 && matrix[i-1][j-1] == matrix[i][j] {
|
|
return backtrace(s, t, p, i-1, j-1, matrix)
|
|
}
|
|
return []Operation{}
|
|
}
|