fix: diagnose opaque qualification predicates
Add fixed attestation, factory guard and restoration reasons without changing fail-closed predicates or cleanup order. Retain nested reasons under joined ownership vetoes and distinguish prior cleanup veto from a new restoration failure. Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
1 parent
63cdc7d490
commit
83921350fd
5 files changed
+310
-32
No files matched your search
@@ -1,6 +1,7 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
)
|
||||
@@ -43,6 +44,23 @@ const (
|
||||
reasonDefinition
|
||||
reasonRuntime
|
||||
reasonCollector
|
||||
reasonGuard
|
||||
reasonWorkerScan
|
||||
reasonEngine
|
||||
reasonArgv
|
||||
reasonParent
|
||||
reasonStarttime
|
||||
reasonQueue
|
||||
reasonVersion
|
||||
reasonRulesRead
|
||||
reasonMode
|
||||
reasonPlanStore
|
||||
reasonContext
|
||||
reasonQueuePresentOrUnreadable
|
||||
reasonNFTRead
|
||||
reasonNFTPresent
|
||||
reasonBaseline
|
||||
reasonPriorCleanupVeto
|
||||
)
|
||||
|
||||
func (s qualificationStage) String() string {
|
||||
@@ -54,7 +72,7 @@ func (s qualificationStage) String() string {
|
||||
}
|
||||
|
||||
func (r qualificationReason) String() string {
|
||||
names := [...]string{"unknown", "execution", "output_bound", "metrics", "origin", "tls_evidence", "framing", "body", "mime", "worker_identity", "rules", "files", "definition", "runtime", "collector"}
|
||||
names := [...]string{"unknown", "execution", "output_bound", "metrics", "origin", "tls_evidence", "framing", "body", "mime", "worker_identity", "rules", "files", "definition", "runtime", "collector", "guard", "worker_scan", "engine", "argv", "parent", "starttime", "queue", "version", "rules_read", "mode", "plan_store", "context", "queue_present_or_unreadable", "nft_read", "nft_present", "baseline", "prior_cleanup_veto"}
|
||||
if int(r) >= len(names) {
|
||||
return names[0]
|
||||
}
|
||||
@@ -76,7 +94,19 @@ func qualificationOperation(err error, stage qualificationStage) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
return &qualificationDiagnostic{Err: err, Stage: stage}
|
||||
return &qualificationDiagnostic{Err: err, Stage: stage, Reason: qualificationErrorReason(err, reasonUnknown)}
|
||||
}
|
||||
|
||||
func qualificationPredicate(err error, reason qualificationReason) error {
|
||||
return &qualificationDiagnostic{Err: err, Reason: reason}
|
||||
}
|
||||
|
||||
func qualificationErrorReason(err error, fallback qualificationReason) qualificationReason {
|
||||
var diagnostic *qualificationDiagnostic
|
||||
if errors.As(err, &diagnostic) && diagnostic.Reason != reasonUnknown {
|
||||
return diagnostic.Reason
|
||||
}
|
||||
return fallback
|
||||
}
|
||||
|
||||
func attestationMismatch(a, b qualificationAttestation) qualificationReason {
|
||||
|
||||
@@ -140,12 +140,15 @@ func TestQualificationDiagnosticVetoAndFinalStages(t *testing.T) {
|
||||
|
||||
func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) {
|
||||
secret := errors.New("PRIVATE sentinel")
|
||||
for _, mode := range []string{"cleanup", "restore", "guard", "ack", "success"} {
|
||||
for _, mode := range []string{"cleanup", "owned_cleanup", "restore", "guard", "ack", "success"} {
|
||||
t.Run(mode, func(t *testing.T) {
|
||||
var primary error
|
||||
if mode == "cleanup" {
|
||||
primary = &qualificationCleanupFailure{Err: secret}
|
||||
}
|
||||
if mode == "owned_cleanup" {
|
||||
primary = errors.Join(context.Canceled, &managedRecoveryFatal{Err: &managedAssetCleanupFailure{Err: secret}})
|
||||
}
|
||||
restores, guards, acks := 0, 0, 0
|
||||
err := qualificationFinalize(primary, func(context.Context) error {
|
||||
restores++
|
||||
@@ -187,13 +190,38 @@ func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) {
|
||||
if mode != "ack" && acks != 0 {
|
||||
t.Fatal("ACK passed failed gate")
|
||||
}
|
||||
if mode == "cleanup" && (restores != 0 || guards != 0) {
|
||||
t.Fatal("cleanup failure retried")
|
||||
if mode == "cleanup" || mode == "owned_cleanup" {
|
||||
if restores != 0 || guards != 0 || acks != 0 || !strings.Contains(out.String(), "reason=prior_cleanup_veto") {
|
||||
t.Fatal("cleanup failure retried or misdiagnosed", out.String())
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestQualificationOpaqueAttestationReasonUnderPostDNSGuard(t *testing.T) {
|
||||
secret := errors.New("PRIVATE attestation path env argv")
|
||||
q, s, registry, _, transfers := qualifierFixture(t)
|
||||
attest, calls := q.attest, 0
|
||||
q.attest = func(ctx context.Context, pid int, args []string, d strategyDefinition) (qualificationAttestation, error) {
|
||||
calls++
|
||||
if calls == 3 { // Initial attestation, pre-DNS, then post-DNS.
|
||||
return qualificationAttestation{}, qualificationPredicate(secret, reasonWorkerScan)
|
||||
}
|
||||
return attest(ctx, pid, args, d)
|
||||
}
|
||||
proof, err := q.complete(context.Background(), s, registry)
|
||||
if !errors.Is(err, errResourcePlan) || !errors.Is(err, secret) || proof.seal != "" || *transfers != 0 {
|
||||
t.Fatal("ownership veto or execution order changed", err, *transfers)
|
||||
}
|
||||
var out bytes.Buffer
|
||||
writeQualificationDiagnostics(&out, err)
|
||||
if strings.Contains(out.String(), "PRIVATE") || strings.Contains(out.String(), "reason=unknown") ||
|
||||
strings.Count(out.String(), "stage=post_dns_guard reason=worker_scan candidate=1 resource=1 attempt=1 tls=tls12") != 2 {
|
||||
t.Fatal(out.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestQualificationAttestationErrorRetainsOwnershipVeto(t *testing.T) {
|
||||
q, s, registry, _, _ := qualifierFixture(t)
|
||||
attest, calls := q.attest, 0
|
||||
|
||||
@@ -0,0 +1,195 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"go/ast"
|
||||
"go/format"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestQualificationRestorePredicatesAndOrder(t *testing.T) {
|
||||
secret := errors.New("PRIVATE nft process baseline sentinel")
|
||||
for _, reason := range []qualificationReason{reasonContext, reasonGuard, reasonMode, reasonPlanStore, reasonRuntime, reasonWorkerScan, reasonQueuePresentOrUnreadable, reasonNFTRead, reasonNFTPresent, reasonBaseline, reasonUnknown} {
|
||||
t.Run(reason.String(), func(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
if reason == reasonContext {
|
||||
cancel()
|
||||
}
|
||||
var order []string
|
||||
q := resourceQualifier{guard: func() error {
|
||||
order = append(order, "guard")
|
||||
if reason == reasonGuard {
|
||||
return secret
|
||||
}
|
||||
if reason == reasonMode || reason == reasonPlanStore || reason == reasonRuntime {
|
||||
return qualificationPredicate(secret, reason)
|
||||
}
|
||||
return nil
|
||||
}}
|
||||
q.runtime.nft = func(_ context.Context, input string) (string, error) {
|
||||
order = append(order, "nft")
|
||||
if input != "list tables\n" {
|
||||
t.Fatal(input)
|
||||
}
|
||||
if reason == reasonNFTRead {
|
||||
return "", secret
|
||||
}
|
||||
if reason == reasonNFTPresent {
|
||||
return "table inet " + managedAssetTable, nil
|
||||
}
|
||||
return "", nil
|
||||
}
|
||||
err := q.restoreBaseline(ctx, func() error {
|
||||
order = append(order, "worker_queue")
|
||||
if reason == reasonWorkerScan || reason == reasonQueuePresentOrUnreadable {
|
||||
return qualificationPredicate(secret, reason)
|
||||
}
|
||||
return nil
|
||||
}, func() error {
|
||||
order = append(order, "baseline")
|
||||
if reason == reasonBaseline {
|
||||
return errResourcePlan
|
||||
}
|
||||
return nil
|
||||
})
|
||||
want := []string{"guard", "worker_queue", "nft", "baseline"}
|
||||
switch reason {
|
||||
case reasonContext:
|
||||
want = nil
|
||||
case reasonGuard, reasonMode, reasonPlanStore, reasonRuntime:
|
||||
want = want[:1]
|
||||
case reasonWorkerScan, reasonQueuePresentOrUnreadable:
|
||||
want = want[:2]
|
||||
case reasonNFTRead, reasonNFTPresent:
|
||||
want = want[:3]
|
||||
}
|
||||
if !reflect.DeepEqual(order, want) {
|
||||
t.Fatal(order, want)
|
||||
}
|
||||
if reason == reasonUnknown {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return
|
||||
}
|
||||
if !errors.Is(err, errResourcePlan) || errors.Is(err, secret) {
|
||||
t.Fatal("original restore classification changed", err)
|
||||
}
|
||||
var out bytes.Buffer
|
||||
writeQualificationDiagnostics(&out, qualificationOperation(err, stageRestore))
|
||||
if !strings.Contains(out.String(), "role=cleanup stage=restore reason="+reason.String()) || strings.Contains(out.String(), "PRIVATE") {
|
||||
t.Fatal(out.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Check the actual production factory, not just injected diagnostic errors. This
|
||||
// pins opaque predicate order/strictness without starting workers or changing nft.
|
||||
func TestQualificationProductionPredicateMap(t *testing.T) {
|
||||
fset := token.NewFileSet()
|
||||
f, err := parser.ParseFile(fset, "resource_qualify.go", nil, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
text := func(n ast.Node) string {
|
||||
var b bytes.Buffer
|
||||
if err := format.Node(&b, fset, n); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
var attest *ast.FuncLit
|
||||
var restore, guard, noWorker, onlyWorker string
|
||||
ast.Inspect(f, func(n ast.Node) bool {
|
||||
if fn, ok := n.(*ast.FuncDecl); ok {
|
||||
switch fn.Name.Name {
|
||||
case "qualificationNoWorker":
|
||||
noWorker = text(fn.Body)
|
||||
case "qualificationOnlyWorker":
|
||||
onlyWorker = text(fn.Body)
|
||||
}
|
||||
}
|
||||
a, ok := n.(*ast.AssignStmt)
|
||||
if !ok || len(a.Lhs) != 1 || len(a.Rhs) != 1 {
|
||||
return true
|
||||
}
|
||||
if text(a.Lhs[0]) == "q.attest" {
|
||||
attest, _ = a.Rhs[0].(*ast.FuncLit)
|
||||
}
|
||||
if text(a.Lhs[0]) == "q.restore" {
|
||||
restore = text(a.Rhs[0])
|
||||
}
|
||||
if text(a.Lhs[0]) == "q.guard" && guard == "" {
|
||||
guard = text(a.Rhs[0])
|
||||
}
|
||||
return true
|
||||
})
|
||||
if attest == nil || !strings.Contains(restore, "q.restoreBaseline(ctx, qualificationNoWorker, func() error { return qualificationBaseline(d.directory) })") {
|
||||
t.Fatal("production restore wiring changed", restore)
|
||||
}
|
||||
for _, check := range []string{
|
||||
"if e := qualificationMode(config, strategies, d); e != nil {\n\t\treturn qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonMode))",
|
||||
"if e := s.guard(); e != nil {\n\t\treturn qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonPlanStore))",
|
||||
"if e := r.guard(); e != nil {\n\t\treturn qualificationPredicate(e, qualificationErrorReason(e, reasonRuntime))",
|
||||
} {
|
||||
if !strings.Contains(guard, check) {
|
||||
t.Fatal("production guard predicate changed", guard)
|
||||
}
|
||||
}
|
||||
if !strings.Contains(noWorker, "qualificationOnlyWorker(0)") || !strings.Contains(noWorker, "qualificationPredicate(e, reasonWorkerScan)") ||
|
||||
!strings.Contains(noWorker, "managedAssetQueueReady(0)") || !strings.Contains(noWorker, "e != nil || occupied") || !strings.Contains(noWorker, "qualificationPredicate(errResourcePlan, reasonQueuePresentOrUnreadable)") {
|
||||
t.Fatal("production worker/queue predicate changed", noWorker)
|
||||
}
|
||||
if !strings.Contains(onlyWorker, "if errors.Is(e, os.ErrNotExist) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\treturn errResourcePlan") {
|
||||
t.Fatal("unexpected procfs readlink errors must remain fail-closed", onlyWorker)
|
||||
}
|
||||
var got []string
|
||||
for _, stmt := range attest.Body.List {
|
||||
branch, ok := stmt.(*ast.IfStmt)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
predicate := text(branch.Cond)
|
||||
if branch.Init != nil {
|
||||
predicate = text(branch.Init) + "; " + predicate
|
||||
}
|
||||
ret, ok := branch.Body.List[0].(*ast.ReturnStmt)
|
||||
if !ok || len(ret.Results) != 2 {
|
||||
t.Fatal("unexpected attestation branch", text(branch))
|
||||
}
|
||||
got = append(got, predicate+" => "+text(ret.Results[1]))
|
||||
}
|
||||
want := []string{
|
||||
"e := q.guard(); e != nil => qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonGuard))",
|
||||
"qualificationOnlyWorker(pid) != nil => qualificationPredicate(errResourcePlan, reasonWorkerScan)",
|
||||
`engine == nil || engine.validate() != nil || engine.running(fmt.Sprintf("/proc/%d/exe", pid)) != nil => qualificationPredicate(errResourcePlan, reasonEngine)`,
|
||||
`e != nil || string(cmd) != strings.Join(append([]string{qualificationEngine}, args...), "\x00")+"\x00" => qualificationPredicate(errResourcePlan, reasonArgv)`,
|
||||
"e != nil => qualificationPredicate(e, reasonParent)",
|
||||
"end < 0 => qualificationPredicate(errResourcePlan, reasonParent)",
|
||||
"len(tail) < 2 || tail[1] != strconv.Itoa(os.Getpid()) => qualificationPredicate(errResourcePlan, reasonParent)",
|
||||
"e != nil => qualificationPredicate(e, reasonStarttime)",
|
||||
"e != nil || !ready => qualificationPredicate(errResourcePlan, reasonQueue)",
|
||||
"e != nil => qualificationPredicate(e, reasonFiles)",
|
||||
"version.Run() != nil => qualificationPredicate(errResourcePlan, reasonVersion)",
|
||||
"!valid => qualificationPredicate(errResourcePlan, reasonVersion)",
|
||||
`e != nil || strings.TrimSpace(rules) == "" => qualificationPredicate(errResourcePlan, reasonRulesRead)`,
|
||||
}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("production attestation predicates:\n%v\nwant:\n%v", got, want)
|
||||
}
|
||||
// The factory's strict mode check must precede any store, worker or nft access.
|
||||
q := newResourceQualifier("", "", managedDeps{lookup: func(string) (string, bool) { return "", false }}, nil)
|
||||
defer q.close()
|
||||
_, err = q.attest(context.Background(), 0, nil, strategyDefinition{})
|
||||
if !errors.Is(err, errResourcePlan) || qualificationErrorReason(err, reasonUnknown) != reasonMode {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
@@ -151,11 +151,34 @@ func (s *resourcePlanStore) protectBaseline() error {
|
||||
}
|
||||
func qualificationNoWorker() error {
|
||||
if e := qualificationOnlyWorker(0); e != nil {
|
||||
return e
|
||||
return qualificationPredicate(e, reasonWorkerScan)
|
||||
}
|
||||
occupied, e := managedAssetQueueReady(0)
|
||||
if e != nil || occupied {
|
||||
return errResourcePlan
|
||||
return qualificationPredicate(errResourcePlan, reasonQueuePresentOrUnreadable)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (q resourceQualifier) restoreBaseline(ctx context.Context, noWorker, baseline func() error) error {
|
||||
if ctx.Err() != nil {
|
||||
return qualificationPredicate(errResourcePlan, reasonContext)
|
||||
}
|
||||
if e := q.guard(); e != nil {
|
||||
return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonGuard))
|
||||
}
|
||||
if e := noWorker(); e != nil {
|
||||
return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonUnknown))
|
||||
}
|
||||
tables, e := q.runtime.nft(ctx, "list tables\n")
|
||||
if e != nil {
|
||||
return qualificationPredicate(errResourcePlan, reasonNFTRead)
|
||||
}
|
||||
if strings.Contains(tables, "table inet "+managedAssetTable) {
|
||||
return qualificationPredicate(errResourcePlan, reasonNFTPresent)
|
||||
}
|
||||
if e := baseline(); e != nil {
|
||||
return qualificationPredicate(e, reasonBaseline)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -242,55 +265,57 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP
|
||||
q.runtime = r
|
||||
q.source = func() (resourceMonitorSource, error) { return readResourceMonitorSource(config, d.lookup, s.files.key) }
|
||||
q.guard = func() error {
|
||||
if qualificationMode(config, strategies, d) != nil || s.guard() != nil {
|
||||
return errResourcePlan
|
||||
if e := qualificationMode(config, strategies, d); e != nil {
|
||||
return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonMode))
|
||||
}
|
||||
return r.guard()
|
||||
if e := s.guard(); e != nil {
|
||||
return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonPlanStore))
|
||||
}
|
||||
if e := r.guard(); e != nil {
|
||||
return qualificationPredicate(e, qualificationErrorReason(e, reasonRuntime))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
q.restore = func(ctx context.Context) error {
|
||||
if ctx.Err() != nil || q.guard() != nil || qualificationNoWorker() != nil {
|
||||
return errResourcePlan
|
||||
}
|
||||
tables, e := r.nft(ctx, "list tables\n")
|
||||
if e != nil || strings.Contains(tables, "table inet "+managedAssetTable) {
|
||||
return errResourcePlan
|
||||
}
|
||||
return qualificationBaseline(d.directory)
|
||||
return q.restoreBaseline(ctx, qualificationNoWorker, func() error { return qualificationBaseline(d.directory) })
|
||||
}
|
||||
q.attest = func(ctx context.Context, pid int, args []string, definition strategyDefinition) (qualificationAttestation, error) {
|
||||
if q.guard() != nil || qualificationOnlyWorker(pid) != nil {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
if e := q.guard(); e != nil {
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonGuard))
|
||||
}
|
||||
if qualificationOnlyWorker(pid) != nil {
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonWorkerScan)
|
||||
}
|
||||
if engine == nil || engine.validate() != nil || engine.running(fmt.Sprintf("/proc/%d/exe", pid)) != nil {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonEngine)
|
||||
}
|
||||
cmd, e := os.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
|
||||
if e != nil || string(cmd) != strings.Join(append([]string{qualificationEngine}, args...), "\x00")+"\x00" {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonArgv)
|
||||
}
|
||||
stat, e := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid))
|
||||
if e != nil {
|
||||
return qualificationAttestation{}, e
|
||||
return qualificationAttestation{}, qualificationPredicate(e, reasonParent)
|
||||
}
|
||||
end := strings.LastIndex(string(stat), ") ")
|
||||
if end < 0 {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonParent)
|
||||
}
|
||||
tail := strings.Fields(string(stat)[end+2:])
|
||||
if len(tail) < 2 || tail[1] != strconv.Itoa(os.Getpid()) {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonParent)
|
||||
}
|
||||
start, e := readMonitorProcessStarttime(pid)
|
||||
if e != nil {
|
||||
return qualificationAttestation{}, e
|
||||
return qualificationAttestation{}, qualificationPredicate(e, reasonStarttime)
|
||||
}
|
||||
ready, e := r.queue(pid)
|
||||
if e != nil || !ready {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonQueue)
|
||||
}
|
||||
hash, e := q.filesHash()
|
||||
if e != nil {
|
||||
return qualificationAttestation{}, e
|
||||
return qualificationAttestation{}, qualificationPredicate(e, reasonFiles)
|
||||
}
|
||||
versionCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
defer cancel()
|
||||
@@ -299,7 +324,7 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP
|
||||
version.Stdout = &playerBoundedWriter{dst: &output, limit: 4096}
|
||||
version.Stderr = io.Discard
|
||||
if version.Run() != nil {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonVersion)
|
||||
}
|
||||
fields := strings.Fields(output.String())
|
||||
valid := false
|
||||
@@ -309,11 +334,11 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP
|
||||
}
|
||||
}
|
||||
if !valid {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonVersion)
|
||||
}
|
||||
rules, e := r.nft(ctx, "list table inet "+managedAssetTable+"\n")
|
||||
if e != nil || strings.TrimSpace(rules) == "" {
|
||||
return qualificationAttestation{}, errResourcePlan
|
||||
return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonRulesRead)
|
||||
}
|
||||
return qualificationAttestation{Collector: "owned-resource-nfq-v1", Runtime: "nfqws2-1.0.2", Definition: planDigest(definition), LuaHash: hash, RulesHash: planDigest(rules), WorkerArgsHash: planDigest(args), Queue: managedAssetQueue, PID: pid, StartTime: start}, nil
|
||||
}
|
||||
|
||||
@@ -93,7 +93,7 @@ func qualificationFinalize(err error, restore func(context.Context) error, guard
|
||||
return restoreErr
|
||||
}) {
|
||||
if restoreErr == nil {
|
||||
restoreErr = errResourcePlan
|
||||
return qualificationOperation(qualificationPredicate(errResourcePlan, reasonPriorCleanupVeto), stageRestore)
|
||||
}
|
||||
return qualificationOperation(restoreErr, stageRestore)
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user