feat: execute continuity satisfaction through commit
CI / test (push) Successful in 11s

This commit is contained in:
m
2026-08-16 16:19:23 +03:00
parent fe0b93739f
commit 4a165b5238
25 changed files with 1249 additions and 28 deletions
+96
View File
@@ -0,0 +1,96 @@
package continuityexecutor
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/url"
"strings"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
"git.cin.su/m/Assistant/contracts/continuity"
"git.cin.su/m/Assistant/modules/commit/ports"
)
type Adapter struct {
baseURL string
token string
client *http.Client
}
func New(baseURL, token string, client *http.Client) (*Adapter, error) {
baseURL = strings.TrimRight(baseURL, "/")
if baseURL == "" || token == "" || client == nil {
return nil, fmt.Errorf("continuity executor requires base URL, token, and HTTP client")
}
if _, err := url.ParseRequestURI(baseURL); err != nil {
return nil, fmt.Errorf("invalid continuity executor URL: %w", err)
}
return &Adapter{baseURL: baseURL, token: token, client: client}, nil
}
func (a *Adapter) Execute(action commitcontract.AuthorizedAction) ports.ExecutionResult {
if action.Proposal.CapabilityID != commitcontract.CapabilityContinuityTransition || action.Proposal.Operation != commitcontract.OperationSatisfyDelivered {
return ports.ExecutionResult{Known: true, Succeeded: false}
}
command := continuity.SatisfyDeliveredCommand{
ActionIntentID: continuity.CommittedActionIntentID(action.Proposal.IntentID),
AuthorizedActionID: continuity.CommittedAuthorizedActionID(action.ID),
OwnerPrincipalID: action.PrincipalID,
Subject: action.Proposal.ContinuitySubject,
}
body, err := json.Marshal(command)
if err != nil {
return ports.ExecutionResult{Known: true, Succeeded: false}
}
request, err := http.NewRequest(http.MethodPost, a.baseURL+"/v1/internal/executor/satisfy-delivered", bytes.NewReader(body))
if err != nil {
return ports.ExecutionResult{Known: true, Succeeded: false}
}
request.Header.Set("Authorization", "Bearer "+a.token)
request.Header.Set("Content-Type", "application/json")
response, err := a.client.Do(request)
if err != nil {
return ports.ExecutionResult{Known: false}
}
defer response.Body.Close()
if response.StatusCode == http.StatusOK {
var receipt continuity.ActionReceipt
if json.NewDecoder(response.Body).Decode(&receipt) != nil ||
receipt.ActionIntentID != command.ActionIntentID || receipt.AuthorizedActionID != command.AuthorizedActionID ||
receipt.ResultState != continuity.ProspectiveSatisfied {
return ports.ExecutionResult{Known: false}
}
return ports.ExecutionResult{Known: true, Succeeded: true}
}
if response.StatusCode >= 400 && response.StatusCode < 500 {
return ports.ExecutionResult{Known: true, Succeeded: false}
}
return ports.ExecutionResult{Known: false}
}
func (a *Adapter) Reconcile(action commitcontract.AuthorizedAction) ports.ExecutionResult {
endpoint := a.baseURL + "/v1/internal/executor/receipts/" + url.PathEscape(string(action.Proposal.IntentID))
request, err := http.NewRequest(http.MethodGet, endpoint, nil)
if err != nil {
return ports.ExecutionResult{Known: false}
}
request.Header.Set("Authorization", "Bearer "+a.token)
response, err := a.client.Do(request)
if err != nil {
return ports.ExecutionResult{Known: false}
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return ports.ExecutionResult{Known: false}
}
var receipt continuity.ActionReceipt
if json.NewDecoder(response.Body).Decode(&receipt) != nil ||
receipt.ActionIntentID != continuity.CommittedActionIntentID(action.Proposal.IntentID) ||
receipt.AuthorizedActionID != continuity.CommittedAuthorizedActionID(action.ID) ||
receipt.OwnerPrincipalID != action.PrincipalID || receipt.Subject != action.Proposal.ContinuitySubject {
return ports.ExecutionResult{Known: false}
}
return ports.ExecutionResult{Known: true, Succeeded: receipt.ResultState == continuity.ProspectiveSatisfied}
}
@@ -0,0 +1,89 @@
package continuityexecutor
import (
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
"git.cin.su/m/Assistant/contracts/continuity"
)
func TestExecuteAndReconcileUseTypedReceipt(t *testing.T) {
action := testAction()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("Authorization") != "Bearer secret" {
http.Error(w, "denied", http.StatusUnauthorized)
return
}
receipt := continuity.ActionReceipt{
ActionIntentID: continuity.CommittedActionIntentID(action.Proposal.IntentID), AuthorizedActionID: continuity.CommittedAuthorizedActionID(action.ID),
OwnerPrincipalID: action.PrincipalID, Subject: action.Proposal.ContinuitySubject,
ResultState: continuity.ProspectiveSatisfied, ResultRevision: 5,
}
_ = json.NewEncoder(w).Encode(receipt)
}))
defer server.Close()
adapter, err := New(server.URL, "secret", server.Client())
if err != nil {
t.Fatal(err)
}
if result := adapter.Execute(action); !result.Known || !result.Succeeded {
t.Fatalf("execute result = %#v", result)
}
if result := adapter.Reconcile(action); !result.Known || !result.Succeeded {
t.Fatalf("reconcile result = %#v", result)
}
}
func TestAcknowledgementLossReconcilesWithoutDuplicatePost(t *testing.T) {
action := testAction()
posts := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
posts++
hijacker, ok := w.(http.Hijacker)
if !ok {
t.Fatal("test server cannot simulate acknowledgement loss")
}
connection, _, err := hijacker.Hijack()
if err != nil {
t.Fatal(err)
}
_ = connection.Close()
return
}
receipt := continuity.ActionReceipt{
ActionIntentID: continuity.CommittedActionIntentID(action.Proposal.IntentID), AuthorizedActionID: continuity.CommittedAuthorizedActionID(action.ID),
OwnerPrincipalID: action.PrincipalID, Subject: action.Proposal.ContinuitySubject,
ResultState: continuity.ProspectiveSatisfied, ResultRevision: 5,
}
_ = json.NewEncoder(w).Encode(receipt)
}))
defer server.Close()
adapter, err := New(server.URL, "secret", server.Client())
if err != nil {
t.Fatal(err)
}
if result := adapter.Execute(action); result.Known {
t.Fatalf("lost acknowledgement was treated as known: %#v", result)
}
if result := adapter.Reconcile(action); !result.Known || !result.Succeeded {
t.Fatalf("reconciliation result = %#v", result)
}
if posts != 1 {
t.Fatalf("effect was posted %d times", posts)
}
}
func testAction() commitcontract.AuthorizedAction {
return commitcontract.AuthorizedAction{
ID: "authorized-1", PrincipalID: "principal-1", State: commitcontract.ActionAuthorized,
Proposal: commitcontract.ActionProposal{
IntentID: "intent-1", CapabilityID: commitcontract.CapabilityContinuityTransition,
Operation: commitcontract.OperationSatisfyDelivered,
ContinuitySubject: continuity.SatisfyDeliveredSubject{ProspectiveItemID: "prospective-1", ExpectedRevision: 4, FromState: continuity.ProspectiveDelivered, ToState: continuity.ProspectiveSatisfied, EvidenceRef: "artifact://evidence/1"},
},
}
}