mirror of
https://github.com/kyverno/kyverno.git
synced 2024-12-14 11:57:48 +00:00
92 lines
2.8 KiB
Go
92 lines
2.8 KiB
Go
package mutate
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/go-logr/logr"
|
|
kyverno "github.com/kyverno/kyverno/pkg/api/kyverno/v1"
|
|
"github.com/kyverno/kyverno/pkg/engine/response"
|
|
"github.com/kyverno/kyverno/pkg/engine/utils"
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
// ProcessPatchJSON6902 ...
|
|
func ProcessPatchJSON6902(ruleName string, patchesJSON6902 []byte, resource unstructured.Unstructured, log logr.Logger) (resp response.RuleResponse, patchedResource unstructured.Unstructured) {
|
|
logger := log.WithValues("rule", ruleName)
|
|
startTime := time.Now()
|
|
logger.V(4).Info("started JSON6902 patch", "startTime", startTime)
|
|
resp.Name = ruleName
|
|
resp.Type = utils.Mutation.String()
|
|
defer func() {
|
|
resp.RuleStats.ProcessingTime = time.Since(startTime)
|
|
logger.V(4).Info("applied JSON6902 patch", "processingTime", resp.RuleStats.ProcessingTime.String())
|
|
}()
|
|
|
|
resourceRaw, err := resource.MarshalJSON()
|
|
if err != nil {
|
|
resp.Success = false
|
|
logger.Error(err, "failed to marshal resource")
|
|
resp.Message = fmt.Sprintf("failed to marshal resource: %v", err)
|
|
return resp, resource
|
|
}
|
|
|
|
patchedResourceRaw, err := utils.ApplyPatchNew(resourceRaw, patchesJSON6902)
|
|
// patchedResourceRaw, err := patchJSON6902(string(resourceRaw), mutation.PatchesJSON6902)
|
|
if err != nil {
|
|
resp.Success = false
|
|
logger.Error(err, "failed to process JSON6902 patches")
|
|
resp.Message = fmt.Sprintf("failed to process JSON6902 patches: %v", err)
|
|
return resp, resource
|
|
}
|
|
|
|
err = patchedResource.UnmarshalJSON(patchedResourceRaw)
|
|
if err != nil {
|
|
logger.Error(err, "failed to unmarshal resource")
|
|
resp.Success = false
|
|
resp.Message = fmt.Sprintf("failed to unmarshal resource: %v", err)
|
|
return resp, resource
|
|
}
|
|
|
|
var decodedPatch []kyverno.Patch
|
|
err = json.Unmarshal(patchesJSON6902, &decodedPatch)
|
|
if err != nil {
|
|
resp.Success = false
|
|
resp.Message = err.Error()
|
|
return resp, resource
|
|
}
|
|
|
|
patchesBytes, err := utils.TransformPatches(decodedPatch)
|
|
if err != nil {
|
|
logger.Error(err, "failed to marshal patches to bytes array")
|
|
resp.Success = false
|
|
resp.Message = fmt.Sprintf("failed to marshal patches to bytes array: %v", err)
|
|
return resp, resource
|
|
}
|
|
|
|
for _, p := range patchesBytes {
|
|
log.V(6).Info("", "patches", string(p))
|
|
}
|
|
|
|
// JSON patches processed successfully
|
|
resp.Success = true
|
|
resp.Message = fmt.Sprintf("successfully process JSON6902 patches")
|
|
resp.Patches = patchesBytes
|
|
return resp, patchedResource
|
|
}
|
|
|
|
func convertPatchesToJSON(patchesJSON6902 string) ([]byte, error) {
|
|
if patchesJSON6902[0] != '[' {
|
|
// If the patch doesn't look like a JSON6902 patch, we
|
|
// try to parse it to json.
|
|
op, err := yaml.YAMLToJSON([]byte(patchesJSON6902))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to convert patchesJSON6902 to JSON: %v", err)
|
|
}
|
|
return op, nil
|
|
}
|
|
|
|
return []byte(patchesJSON6902), nil
|
|
}
|