harn-stdlib 0.10.181

Embedded Harn standard library source catalog
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

import {
  VerificationInputState,
  VerificationRecordedCheck,
  VerificationReuse,
} from "std/verification_types"

/**
 * Read a complete input identity without retaining raw environment values.
 * An unavailable input reader disables reuse for this call.
 *
 * @effects: [host]
 * @errors: []
 */
pub fn __verification_reuse_inputs(reuse: VerificationReuse?) -> VerificationInputState? {
  if reuse == nil || trim(reuse.scope) == "" {
    return nil
  }
  const value = try {
    reuse.inputs()
  } catch {
    nil
  }
  const parsed = schema_parse(value, schema_of(VerificationInputState))
  match parsed {
    Ok(state) -> {
      if state.revision < 0 || trim(state.workspace) == "" || trim(state.source) == ""
        || trim(state.dependencies) == ""
        || trim(state.environment) == "" {
        return nil
      }
      return state
    }
    Err(_) -> { return nil }
  }
}

fn verification_reuse_key(scope: string) -> string {
  return "harn.verification.reuse.${sha256(scope)}"
}

/**
 * Only a positive observation over the same complete inputs can suppress execution.
 *
 * @effects: [state, host]
 * @errors: [backend, invalid_argument]
 */
pub fn __verification_reuse_lookup(
  runtime: HarnessRuntime,
  reuse: VerificationReuse?,
  invocation: string,
  inputs: VerificationInputState?,
) -> VerificationRecordedCheck? {
  if reuse == nil || trim(reuse.scope) == "" {
    return nil
  }
  const stored = runtime.store_get(verification_reuse_key(reuse.scope))
  match schema_parse(stored, schema_of(VerificationRecordedCheck)) {
    Ok(cached) -> {
      const binding = cached.binding
      const result = cached.result
      if inputs != nil && binding != nil && binding.invocation == invocation
        && binding.inputs == inputs
        && cached.execution != "observed"
        && result.status == "completed"
        && result.exit_code == 0
        && result.ok
        && result.success
        && reuse.accept(result)
        && __verification_reuse_inputs(reuse) == inputs {
        return cached + {execution: "reused"}
      }
    }
    Err(_) -> {
    }
  }
  runtime.store_set(verification_reuse_key(reuse.scope), nil)
  return nil
}

/**
 * Bind a successful observation only when the check left its inputs unchanged.
 *
 * @effects: [state, host]
 * @errors: [backend, invalid_argument]
 */
pub fn __verification_reuse_store(
  runtime: HarnessRuntime,
  reuse: VerificationReuse?,
  invocation: string,
  before: VerificationInputState?,
  check: VerificationRecordedCheck,
) -> VerificationRecordedCheck {
  if reuse == nil || trim(reuse.scope) == "" {
    return check
  }
  const result = check.result
  const passed = check.execution == "executed" && result.status == "completed"
    && result.exit_code == 0
    && result.ok
    && result.success
  const accepted = passed && reuse.accept(result)
  const after = __verification_reuse_inputs(reuse)
  const bound = if accepted && before != nil && before == after {
    check + {binding: {invocation: invocation, inputs: before}}
  } else {
    nil
  }
  runtime.store_set(verification_reuse_key(reuse.scope), bound)
  return bound ?? check
}