e7a89a4a42
When graph swapping (which is quite common) we only use the newly-made resource if the Cmp function between the two shows a difference. If the old resource has previously received a value via send/recv, then when it is compared to the new value, it will almost always be different. As a result, we need to run send/recv on the newly made graph to make sure it has up-to-date values before we compare. This has to happen after autogrouping since the resources can often be autogrouped and any child grouped resource will cause a remake of all of the other children and parents. It turns out that the actual send/recv properties were being compared as well, and for unknown reasons (tunnel vision perhaps) they are often not identical. Skip comparing these for now until we find a fix or understanding of how to make them identical.
438 lines
12 KiB
Go
438 lines
12 KiB
Go
// Mgmt
|
|
// Copyright (C) 2013-2024+ James Shubin and the project contributors
|
|
// Written by James Shubin <james@shubin.ca> and the project contributors
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package engine
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/purpleidea/mgmt/pgraph"
|
|
"github.com/purpleidea/mgmt/util/errwrap"
|
|
)
|
|
|
|
// ResCmp compares two resources by checking multiple aspects. This is the main
|
|
// entry point for running all the compare steps on two resources. This code is
|
|
// very similar to AdaptCmp.
|
|
func ResCmp(r1, r2 Res) error {
|
|
if r1.Kind() != r2.Kind() {
|
|
return fmt.Errorf("kind differs")
|
|
}
|
|
if r1.Name() != r2.Name() {
|
|
return fmt.Errorf("name differs")
|
|
}
|
|
|
|
if err := r1.Cmp(r2); err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: do we need to compare other traits/metaparams?
|
|
|
|
m1 := r1.MetaParams()
|
|
m2 := r2.MetaParams()
|
|
if (m1 == nil) != (m2 == nil) { // xor
|
|
return fmt.Errorf("meta params differ")
|
|
}
|
|
if m1 != nil && m2 != nil {
|
|
if err := m1.Cmp(m2); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
r1x, ok1 := r1.(RefreshableRes)
|
|
r2x, ok2 := r2.(RefreshableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("refreshable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1x.Refresh() != r2x.Refresh() {
|
|
return fmt.Errorf("refresh differs")
|
|
}
|
|
}
|
|
|
|
// compare meta params for resources with auto edges
|
|
r1e, ok1 := r1.(EdgeableRes)
|
|
r2e, ok2 := r2.(EdgeableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("edgeable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1e.AutoEdgeMeta().Cmp(r2e.AutoEdgeMeta()) != nil {
|
|
return fmt.Errorf("autoedge differs")
|
|
}
|
|
}
|
|
|
|
// compare meta params for resources with auto grouping
|
|
r1g, ok1 := r1.(GroupableRes)
|
|
r2g, ok2 := r2.(GroupableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("groupable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1g.AutoGroupMeta().Cmp(r2g.AutoGroupMeta()) != nil {
|
|
return fmt.Errorf("autogroup differs")
|
|
}
|
|
|
|
// if resources are grouped, are the groups the same?
|
|
if i, j := r1g.GetGroup(), r2g.GetGroup(); len(i) != len(j) {
|
|
return fmt.Errorf("autogroup groups differ")
|
|
} else if len(i) > 0 { // trick the golinter
|
|
|
|
// Sort works with Res, so convert the lists to that
|
|
iRes := []Res{}
|
|
for _, r := range i {
|
|
res := r.(Res)
|
|
iRes = append(iRes, res)
|
|
}
|
|
jRes := []Res{}
|
|
for _, r := range j {
|
|
res := r.(Res)
|
|
jRes = append(jRes, res)
|
|
}
|
|
|
|
ix, jx := Sort(iRes), Sort(jRes) // now sort :)
|
|
for k := range ix {
|
|
// compare sub resources
|
|
if err := ResCmp(ix[k], jx[k]); err != nil {
|
|
//fmt.Printf("bad Cmp: %+v <> %+v for: %+v <> %+v err: %+v\n", r1, r2, ix[k], jx[k], err)
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
r1r, ok1 := r1.(RecvableRes)
|
|
r2r, ok2 := r2.(RecvableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("recvable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
v1 := r1r.Recv()
|
|
v2 := r2r.Recv()
|
|
|
|
// XXX: Our Send/Recv in the lib/main.go doesn't seem to be
|
|
// pulling this in, so this always compares differently. We can
|
|
// comment it out for now, since it's not too consequential.
|
|
// XXX: Find out what the issue is and fix it for here and send.
|
|
// XXX: The below errors are commented out until this is fixed.
|
|
if (v1 == nil) != (v2 == nil) { // xor
|
|
//return fmt.Errorf("recv params differ")
|
|
}
|
|
if v1 != nil && v2 != nil {
|
|
if len(v1) != len(v2) {
|
|
//return fmt.Errorf("recv param lengths differ")
|
|
}
|
|
for key, send1 := range v1 { // map[string]*engine.Send
|
|
send2, exists := v2[key]
|
|
if !exists {
|
|
//return fmt.Errorf("recv param key %s doesn't exist", key)
|
|
}
|
|
if (send1 == nil) != (send2 == nil) { // xor
|
|
//return fmt.Errorf("recv param key %s send differs", key)
|
|
}
|
|
if send1 != nil && send2 != nil && send1.Key != send2.Key {
|
|
//return fmt.Errorf("recv param key %s send key differs (%v != %v)", key, send1.Key, send2.Key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
r1s, ok1 := r1.(SendableRes)
|
|
r2s, ok2 := r2.(SendableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("sendable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
s1 := r1s.Sent()
|
|
s2 := r2s.Sent()
|
|
|
|
// XXX: Our Send/Recv in the lib/main.go doesn't seem to be
|
|
// pulling this in, so this always compares differently. We can
|
|
// comment it out for now, since it's not too consequential.
|
|
// XXX: Find out what the issue is and fix it for here and recv.
|
|
// XXX: The below errors are commented out until this is fixed.
|
|
if (s1 == nil) != (s2 == nil) { // xor
|
|
//return fmt.Errorf("send params differ")
|
|
}
|
|
if s1 != nil && s2 != nil {
|
|
// TODO: reflect.DeepEqual?
|
|
//return fmt.Errorf("send params exist")
|
|
}
|
|
}
|
|
|
|
// compare meta params for resources with reversible traits
|
|
r1v, ok1 := r1.(ReversibleRes)
|
|
r2v, ok2 := r2.(ReversibleRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("reversible differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1v.ReversibleMeta().Cmp(r2v.ReversibleMeta()) != nil {
|
|
return fmt.Errorf("reversible differs")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// AdaptCmp compares two resources by checking multiple aspects. This is the
|
|
// main entry point for running all the compatible compare steps on two
|
|
// resources. This code is very similar to ResCmp.
|
|
func AdaptCmp(r1, r2 CompatibleRes) error {
|
|
if r1.Kind() != r2.Kind() {
|
|
return fmt.Errorf("kind differs")
|
|
}
|
|
if r1.Name() != r2.Name() {
|
|
return fmt.Errorf("name differs")
|
|
}
|
|
|
|
// run `Adapts` instead of `Cmp`
|
|
if err := r1.Adapts(r2); err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: do we need to compare other traits/metaparams?
|
|
|
|
m1 := r1.MetaParams()
|
|
m2 := r2.MetaParams()
|
|
if (m1 == nil) != (m2 == nil) { // xor
|
|
return fmt.Errorf("meta params differ")
|
|
}
|
|
if m1 != nil && m2 != nil {
|
|
if err := m1.Cmp(m2); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// we don't need to compare refresh, since those can always be merged...
|
|
|
|
// compare meta params for resources with auto edges
|
|
r1e, ok1 := r1.(EdgeableRes)
|
|
r2e, ok2 := r2.(EdgeableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("edgeable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1e.AutoEdgeMeta().Cmp(r2e.AutoEdgeMeta()) != nil {
|
|
return fmt.Errorf("autoedge differs")
|
|
}
|
|
}
|
|
|
|
// compare meta params for resources with auto grouping
|
|
r1g, ok1 := r1.(GroupableRes)
|
|
r2g, ok2 := r2.(GroupableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("groupable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1g.AutoGroupMeta().Cmp(r2g.AutoGroupMeta()) != nil {
|
|
return fmt.Errorf("autogroup differs")
|
|
}
|
|
|
|
// if resources are grouped, are the groups the same?
|
|
if i, j := r1g.GetGroup(), r2g.GetGroup(); len(i) != len(j) {
|
|
return fmt.Errorf("autogroup groups differ")
|
|
} else if len(i) > 0 { // trick the golinter
|
|
|
|
// Sort works with Res, so convert the lists to that
|
|
iRes := []Res{}
|
|
for _, r := range i {
|
|
res := r.(Res)
|
|
iRes = append(iRes, res)
|
|
}
|
|
jRes := []Res{}
|
|
for _, r := range j {
|
|
res := r.(Res)
|
|
jRes = append(jRes, res)
|
|
}
|
|
|
|
ix, jx := Sort(iRes), Sort(jRes) // now sort :)
|
|
for k := range ix {
|
|
// compare sub resources
|
|
// TODO: should we use AdaptCmp here?
|
|
// TODO: how would they run `Merge` ? (we don't)
|
|
// this code path will probably not run, because
|
|
// it is called in the lang before autogrouping!
|
|
if err := ResCmp(ix[k], jx[k]); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
r1r, ok1 := r1.(RecvableRes)
|
|
r2r, ok2 := r2.(RecvableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("recvable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
v1 := r1r.Recv()
|
|
v2 := r2r.Recv()
|
|
|
|
// XXX: Our Send/Recv in the lib/main.go doesn't seem to be
|
|
// pulling this in, so this always compares differently. We can
|
|
// comment it out for now, since it's not too consequential.
|
|
// XXX: Find out what the issue is and fix it for here and send.
|
|
// XXX: The below errors are commented out until this is fixed.
|
|
if (v1 == nil) != (v2 == nil) { // xor
|
|
//return fmt.Errorf("recv params differ")
|
|
}
|
|
if v1 != nil && v2 != nil {
|
|
if len(v1) != len(v2) {
|
|
//return fmt.Errorf("recv param lengths differ")
|
|
}
|
|
for key, send1 := range v1 { // map[string]*engine.Send
|
|
send2, exists := v2[key]
|
|
if !exists {
|
|
//return fmt.Errorf("recv param key %s doesn't exist", key)
|
|
}
|
|
if (send1 == nil) != (send2 == nil) { // xor
|
|
//return fmt.Errorf("recv param key %s send differs", key)
|
|
}
|
|
if send1 != nil && send2 != nil && send1.Key != send2.Key {
|
|
//return fmt.Errorf("recv param key %s send key differs (%v != %v)", key, send1.Key, send2.Key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
r1s, ok1 := r1.(SendableRes)
|
|
r2s, ok2 := r2.(SendableRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("sendable differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
s1 := r1s.Sent()
|
|
s2 := r2s.Sent()
|
|
|
|
// XXX: Our Send/Recv in the lib/main.go doesn't seem to be
|
|
// pulling this in, so this always compares differently. We can
|
|
// comment it out for now, since it's not too consequential.
|
|
// XXX: Find out what the issue is and fix it for here and recv.
|
|
// XXX: The below errors are commented out until this is fixed.
|
|
if (s1 == nil) != (s2 == nil) { // xor
|
|
//return fmt.Errorf("send params differ")
|
|
}
|
|
if s1 != nil && s2 != nil {
|
|
// TODO: reflect.DeepEqual?
|
|
//return fmt.Errorf("send params exist")
|
|
}
|
|
}
|
|
|
|
// compare meta params for resources with reversible traits
|
|
r1v, ok1 := r1.(ReversibleRes)
|
|
r2v, ok2 := r2.(ReversibleRes)
|
|
if ok1 != ok2 {
|
|
return fmt.Errorf("reversible differs") // they must be different (optional)
|
|
}
|
|
if ok1 && ok2 {
|
|
if r1v.ReversibleMeta().Cmp(r2v.ReversibleMeta()) != nil {
|
|
return fmt.Errorf("reversible differs")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// VertexCmpFn returns if two vertices are equivalent. It errors if they can't
|
|
// be compared because one is not a vertex. This returns true if equal.
|
|
// TODO: shouldn't the first argument be an `error` instead?
|
|
func VertexCmpFn(v1, v2 pgraph.Vertex) (bool, error) {
|
|
r1, ok := v1.(Res)
|
|
if !ok {
|
|
return false, fmt.Errorf("v1 is not a Res")
|
|
}
|
|
r2, ok := v2.(Res)
|
|
if !ok {
|
|
return false, fmt.Errorf("v2 is not a Res")
|
|
}
|
|
|
|
if err := ResCmp(r1, r2); err != nil {
|
|
//fmt.Printf("bad Cmp: %p %+v <> %p %+v err: %+v\n", r1, r1, r2, r2, err)
|
|
return false, nil
|
|
}
|
|
//fmt.Printf("ok Cmp: %p %+v <> %p %+v\n", r1, r1, r2, r2)
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// EdgeCmpFn returns if two edges are equivalent. It errors if they can't be
|
|
// compared because one is not an edge. This returns true if equal.
|
|
// TODO: shouldn't the first argument be an `error` instead?
|
|
func EdgeCmpFn(e1, e2 pgraph.Edge) (bool, error) {
|
|
edge1, ok := e1.(*Edge)
|
|
if !ok {
|
|
return false, fmt.Errorf("e1 is not an Edge")
|
|
}
|
|
edge2, ok := e2.(*Edge)
|
|
if !ok {
|
|
return false, fmt.Errorf("e2 is not an Edge")
|
|
}
|
|
return edge1.Cmp(edge2) == nil, nil
|
|
}
|
|
|
|
// ResGraphMapper compares two graphs, and gives us a mapping from new to old
|
|
// based on the resource kind and name only. This allows us to know which
|
|
// previous resource might have data to pass on to the new version in the next
|
|
// generation.
|
|
// FIXME: Optimize this for performance since it runs a lot...
|
|
func ResGraphMapper(oldGraph, newGraph *pgraph.Graph) (map[RecvableRes]RecvableRes, error) {
|
|
mapper := make(map[RecvableRes]RecvableRes) // new -> old based on name and kind only?
|
|
cmp := func(r1, r2 Res) error {
|
|
if r1.Kind() != r2.Kind() {
|
|
return fmt.Errorf("kind differs")
|
|
}
|
|
if r1.Name() != r2.Name() {
|
|
return fmt.Errorf("name differs")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX: run this as a topological sort or reverse topological sort?
|
|
for v := range newGraph.Adjacency() { // loop through the vertices (resources)
|
|
r, ok := v.(RecvableRes)
|
|
if !ok {
|
|
continue // skip
|
|
}
|
|
fn := func(vv pgraph.Vertex) (bool, error) {
|
|
rr, ok := vv.(Res)
|
|
if !ok {
|
|
return false, fmt.Errorf("not a Res")
|
|
}
|
|
|
|
if err := cmp(rr, r); err != nil {
|
|
return false, nil
|
|
}
|
|
return true, nil
|
|
}
|
|
vertex, err := oldGraph.VertexMatchFn(fn)
|
|
if err != nil {
|
|
return nil, errwrap.Wrapf(err, "VertexMatchFn failed")
|
|
}
|
|
if vertex == nil {
|
|
continue // skip (error?)
|
|
}
|
|
res, ok := vertex.(RecvableRes)
|
|
if !ok {
|
|
continue // skip (error?)
|
|
}
|
|
|
|
mapper[r] = res
|
|
}
|
|
|
|
return mapper, nil
|
|
}
|