137 lines
4.5 KiB
Go
137 lines
4.5 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
rvboxv1 "github.com/rvbox/rvbox/gen/go/rvbox/v1"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
func TestPayloadRecoveryAfterRestart_REC_STORE_03(t *testing.T) {
|
|
t.Parallel()
|
|
for _, scenario := range []struct {
|
|
name string
|
|
script bool
|
|
empty bool
|
|
alter string
|
|
wantBroken bool
|
|
}{
|
|
{name: "command"},
|
|
{name: "script", script: true},
|
|
{name: "empty script", script: true, empty: true},
|
|
{name: "uncompressed command", alter: "uncompressed"},
|
|
{name: "uncompressed script", script: true, alter: "uncompressed"},
|
|
{name: "missing script", script: true, alter: "missing", wantBroken: true},
|
|
{name: "orphan script", script: true, alter: "command", wantBroken: true},
|
|
{name: "wrong descriptor", script: true, alter: "descriptor", wantBroken: true},
|
|
{name: "damaged frame", alter: "frame", wantBroken: true},
|
|
{name: "wrong stored size", alter: "size", wantBroken: true},
|
|
{name: "opaque descriptor with script", script: true, alter: "opaque", wantBroken: true},
|
|
} {
|
|
t.Run(scenario.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
options := Options{DataDir: filepath.Join(t.TempDir(), "state"), BusyTimeout: time.Second}
|
|
opened, err := Open(ctx, options)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = opened.Close() })
|
|
if _, err := opened.RegisterClientSession(ctx, ClientRegistration{
|
|
ClientID: "recovery-client", Platform: 2, Architecture: "amd64", DaemonVersion: "test",
|
|
DaemonCWD: `C:\`, SupportedShells: []byte{1}, ClientInstanceID: [16]byte{1},
|
|
SessionID: [16]byte{2}, ConnectedAt: time.Now().UTC(),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
body := []byte("Write-Output 'recovery'\r\n")
|
|
if scenario.empty {
|
|
body = []byte{}
|
|
}
|
|
digest := sha256.Sum256(body)
|
|
spec := &rvboxv1.ExecutionSpec{ShellType: rvboxv1.ShellType_SHELL_POWERSHELL}
|
|
if scenario.script {
|
|
spec.Source = &rvboxv1.ExecutionSpec_Script{Script: &rvboxv1.ScriptDescriptor{
|
|
Filename: "recovery.ps1", SizeBytes: uint64(len(body)), Sha256: digest[:],
|
|
}}
|
|
}
|
|
encoded, err := proto.Marshal(spec)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
issue := fixedStoreIssue(0xd2)
|
|
now := time.Now().UTC()
|
|
input := QueueCommandInput{IssueUUID: issue, ClientID: "recovery-client", IssueTime: now,
|
|
ReceiptTime: now, ImmutableSHA256: sha256.Sum256(encoded), ExecutionSpec: encoded,
|
|
ScriptPresent: scenario.script}
|
|
if scenario.script {
|
|
input.ScriptContent = body
|
|
}
|
|
if _, err := opened.QueueCommand(ctx, input); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exec := func(query string, args ...any) {
|
|
t.Helper()
|
|
if _, err := opened.DB().ExecContext(ctx, query, args...); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
switch scenario.alter {
|
|
case "uncompressed":
|
|
exec(`UPDATE commands SET execution_spec = ?, execution_spec_stored_bytes = ?, execution_spec_compression = 1`, encoded, len(encoded))
|
|
case "missing":
|
|
exec(`DELETE FROM command_payloads`)
|
|
case "command", "descriptor", "opaque":
|
|
if scenario.alter == "command" {
|
|
spec.Source = nil
|
|
} else if scenario.alter == "descriptor" {
|
|
spec.GetScript().Sha256 = make([]byte, sha256.Size)
|
|
}
|
|
changed, err := proto.Marshal(spec)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if scenario.alter == "opaque" {
|
|
changed = []byte{0xff}
|
|
}
|
|
stored, err := compressCommandSpec(changed)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exec(`UPDATE commands SET execution_spec = ?, execution_spec_raw_bytes = ?, execution_spec_stored_bytes = ?`, stored, len(changed), len(stored))
|
|
case "frame":
|
|
exec(`UPDATE commands SET execution_spec = zeroblob(execution_spec_stored_bytes)`)
|
|
case "size":
|
|
exec(`UPDATE commands SET execution_spec_stored_bytes = execution_spec_stored_bytes + 1`)
|
|
}
|
|
if err := opened.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
opened, err = Open(ctx, options)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// The deadline makes a nested-query regression fail promptly instead
|
|
// of hanging the test or leaving startup permanently unready.
|
|
recoveryContext, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
defer cancel()
|
|
_, err = opened.RecoverCommandSegments(recoveryContext)
|
|
if scenario.wantBroken {
|
|
if !errors.Is(err, ErrCommittedRangeMissing) {
|
|
t.Fatalf("recovery = %v, want integrity failure", err)
|
|
}
|
|
} else if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := opened.Telemetry(ctx); err != nil {
|
|
t.Fatalf("recovery did not release SQLite connection: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|