Publish outputs to checked destinations and preserve failure evidence
This commit is contained in:
@@ -2,6 +2,7 @@ package diagnostics
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
@@ -73,7 +74,7 @@ func TestPrepareOutputPreservesExistingTranscriptAndChecksParent(t *testing.T) {
|
||||
if got, err := os.ReadFile(output); err != nil || string(got) != "old content" {
|
||||
t.Fatalf("preflight truncated output: %s %v", got, err)
|
||||
}
|
||||
if failures := session.Finalize([]byte("new content"), ReportBundle{}, func([]FileFailure) ReportBundle { return ReportBundle{} }); len(failures) != 0 {
|
||||
if failures := session.finalize(context.Background(), nil, []byte("new content"), nil); len(failures) != 0 {
|
||||
t.Fatal(failures)
|
||||
}
|
||||
if got, err := os.ReadFile(output); err != nil || string(got) != "new content" {
|
||||
@@ -99,21 +100,93 @@ func TestPrepareOutputPreservesExistingTranscriptAndChecksParent(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestAtomicReplacementCleansTemporaryFileAfterRenameFailure(t *testing.T) {
|
||||
func TestOutputPathsUseFilesystemParent(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
resolved := filepath.Join(dir, "destination")
|
||||
child := filepath.Join(resolved, "child")
|
||||
if err := os.MkdirAll(child, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
alias := filepath.Join(dir, "alias")
|
||||
if err := os.Symlink(child, alias); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
parent := alias + string(filepath.Separator) + ".."
|
||||
output := parent + string(filepath.Separator) + "out.json"
|
||||
session, err := PrepareOutput(OutputSelection{TranscriptPath: output, ReportDir: parent, ReportingEnabled: true})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
if err := session.Close(); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
if err := session.Finish(context.Background(), nil, []byte("transcript"), func(error, []FileFailure) (ReportBundle, error) {
|
||||
return ReportBundle{Markdown: []byte("report")}, nil
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for name, want := range map[string]string{"out.json": "transcript", MarkdownFile: "report"} {
|
||||
got, err := os.ReadFile(filepath.Join(resolved, name))
|
||||
if err != nil || string(got) != want {
|
||||
t.Fatalf("%s: %s, %v", name, got, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOutputPublishesThroughTranscriptAndReportSymlinks(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
transcript := filepath.Join(dir, "transcript.json")
|
||||
report := filepath.Join(dir, MarkdownFile)
|
||||
for path, target := range map[string]string{transcript: "actual.json", report: "actual.md"} {
|
||||
if err := os.Symlink(target, path); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
session, err := PrepareOutput(OutputSelection{TranscriptPath: transcript, ReportDir: dir, ReportingEnabled: true})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err = session.Finish(context.Background(), nil, []byte("transcript"), func(error, []FileFailure) (ReportBundle, error) {
|
||||
return ReportBundle{Markdown: []byte("report")}, nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for path, want := range map[string]string{transcript: "transcript", report: "report"} {
|
||||
if _, err := os.Readlink(path); err != nil {
|
||||
t.Errorf("lost symlink at %q: %v", path, err)
|
||||
}
|
||||
got, err := os.ReadFile(path)
|
||||
if err != nil || string(got) != want {
|
||||
t.Fatalf("%s: %s, %v", path, got, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStagingCleansTemporaryResourcesAfterPublicationFailure(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
blocked := filepath.Join(dir, "directory-target")
|
||||
var file stagedFile
|
||||
if err := file.prepare(blocked); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.Mkdir(blocked, 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := atomicReplace(blocked, []byte("new content")); err == nil {
|
||||
if err := file.publish(context.Background(), blocked, []byte("new content")); err == nil {
|
||||
t.Fatal("directory replacement unexpectedly succeeded")
|
||||
}
|
||||
if err := file.close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, entry := range entries {
|
||||
if strings.HasPrefix(entry.Name(), ".audita-write-") {
|
||||
if strings.HasPrefix(entry.Name(), ".audita-output-") {
|
||||
t.Fatalf("replacement left temporary file: %s", entry.Name())
|
||||
}
|
||||
}
|
||||
@@ -125,7 +198,7 @@ func TestDisabledReportingIgnoresUnusableDirectory(t *testing.T) {
|
||||
if err != nil || len(session.ReportPaths()) != 0 {
|
||||
t.Fatalf("disabled reports probed: %+v %v", session, err)
|
||||
}
|
||||
if err := session.Initialize(ReportBundle{}, nil); err != nil {
|
||||
if err := session.Initialize(context.Background(), ReportBundle{}, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(dir, "missing")); !errors.Is(err, os.ErrNotExist) {
|
||||
@@ -151,7 +224,7 @@ func TestStdoutModeInitializesAndFinalizesReports(t *testing.T) {
|
||||
}
|
||||
initial := ReportBundle{Errors: []byte("in progress errors"), Recoveries: []byte("in progress recoveries"), Markdown: []byte("in progress report")}
|
||||
finished := ReportBundle{Errors: []byte("completed errors"), Recoveries: []byte("completed recoveries"), Markdown: []byte("completed report")}
|
||||
if err := session.Initialize(initial, nil); err != nil {
|
||||
if err := session.Initialize(context.Background(), initial, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if session.TranscriptPath() != "" {
|
||||
@@ -163,7 +236,7 @@ func TestStdoutModeInitializesAndFinalizesReports(t *testing.T) {
|
||||
t.Fatalf("initial %s: %s %v", path, got, err)
|
||||
}
|
||||
}
|
||||
if failures := session.Finalize(nil, finished, func([]FileFailure) ReportBundle { return ReportBundle{} }); len(failures) != 0 {
|
||||
if failures := session.finalize(context.Background(), nil, nil, func(error, []FileFailure) (ReportBundle, error) { return finished, nil }); len(failures) != 0 {
|
||||
t.Fatal(failures)
|
||||
}
|
||||
for i, path := range session.ReportPaths() {
|
||||
@@ -181,18 +254,18 @@ func TestInitializeFailureMarksPriorReportFailedBeforeModelWork(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
actual := session.replace
|
||||
session.replace = func(path string, payload []byte) error {
|
||||
session.replace = func(ctx context.Context, path string, payload []byte) error {
|
||||
if filepath.Base(path) == RecoveriesFile && string(payload) == "initial" {
|
||||
return os.ErrPermission
|
||||
}
|
||||
return actual(path, payload)
|
||||
return actual(ctx, path, payload)
|
||||
}
|
||||
modelCalled := false
|
||||
if err := session.Initialize(ReportBundle{Errors: []byte("initial"), Recoveries: []byte("initial"), Markdown: []byte("initial")}, func(failures []FileFailure) ReportBundle {
|
||||
if err := session.Initialize(context.Background(), ReportBundle{Errors: []byte("initial"), Recoveries: []byte("initial"), Markdown: []byte("initial")}, func(_ error, failures []FileFailure) (ReportBundle, error) {
|
||||
if len(failures) != 1 || filepath.Base(failures[0].Path) != RecoveriesFile {
|
||||
t.Fatalf("initialization failures: %+v", failures)
|
||||
}
|
||||
return ReportBundle{Errors: []byte("failed"), Recoveries: []byte("failed"), Markdown: []byte("failed")}
|
||||
return ReportBundle{Errors: []byte("failed"), Recoveries: []byte("failed"), Markdown: []byte("failed")}, nil
|
||||
}); err == nil {
|
||||
modelCalled = true
|
||||
}
|
||||
@@ -215,22 +288,32 @@ func TestFinalizationCollectsFailuresAndRetainsPublishedTranscript(t *testing.T)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := session.Initialize(ReportBundle{Errors: []byte("initial"), Recoveries: []byte("initial"), Markdown: []byte("initial")}, nil); err != nil {
|
||||
if err := session.Initialize(context.Background(), ReportBundle{Errors: []byte("initial"), Recoveries: []byte("initial"), Markdown: []byte("initial")}, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
actual := session.replace
|
||||
session.replace = func(path string, payload []byte) error {
|
||||
var attempts []string
|
||||
session.replace = func(ctx context.Context, path string, payload []byte) error {
|
||||
attempts = append(attempts, filepath.Base(path)+"="+string(payload))
|
||||
if filepath.Base(path) == ErrorsFile && string(payload) == "complete" {
|
||||
return os.ErrPermission
|
||||
}
|
||||
return actual(path, payload)
|
||||
return actual(ctx, path, payload)
|
||||
}
|
||||
complete := ReportBundle{Errors: []byte("complete"), Recoveries: []byte("complete"), Markdown: []byte("complete")}
|
||||
failed := ReportBundle{Errors: []byte("failed"), Recoveries: []byte("failed"), Markdown: []byte("failed")}
|
||||
failures := session.Finalize([]byte("transcript"), complete, func([]FileFailure) ReportBundle { return failed })
|
||||
failures := session.finalize(context.Background(), nil, []byte("transcript"), func(_ error, failures []FileFailure) (ReportBundle, error) {
|
||||
if len(failures) > 0 {
|
||||
return failed, nil
|
||||
}
|
||||
return complete, nil
|
||||
})
|
||||
if len(failures) != 1 || failures[0].Path != filepath.Join(dir, ErrorsFile) {
|
||||
t.Fatalf("failures: %+v", failures)
|
||||
}
|
||||
if got := strings.Join(attempts, ","); got != "errors.yml=complete,recoveries.yml=failed,report.md=failed,errors.yml=failed" {
|
||||
t.Fatalf("unexpected publication attempts: %s", got)
|
||||
}
|
||||
if got, err := os.ReadFile(output); err != nil || string(got) != "transcript" {
|
||||
t.Fatalf("transcript erased: %s %v", got, err)
|
||||
}
|
||||
@@ -241,6 +324,106 @@ func TestFinalizationCollectsFailuresAndRetainsPublishedTranscript(t *testing.T)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFailedRenderingKeepsInitializedEvidenceAfterStreamError(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
delivery := errors.New("stream delivery failed")
|
||||
rendering := errors.New("failed report rendering failed")
|
||||
session, err := PrepareOutput(OutputSelection{
|
||||
Stdout: writerFunc(func([]byte) (int, error) { return 0, delivery }),
|
||||
ReportDir: dir, ReportingEnabled: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
initial := ReportBundle{Errors: []byte("initial"), Recoveries: []byte("initial"), Markdown: []byte("initial")}
|
||||
if err := session.Initialize(ctx, initial, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
session.replace = func(context.Context, string, []byte) error {
|
||||
t.Error("attempted to replace initialized report without a failed bundle")
|
||||
return nil
|
||||
}
|
||||
err = session.Finish(ctx, nil, []byte("transcript"), func(primary error, failures []FileFailure) (ReportBundle, error) {
|
||||
if len(failures) != 1 || !errors.Is(failures[0], delivery) {
|
||||
t.Fatalf("renderer received %v, %v", primary, failures)
|
||||
}
|
||||
return ReportBundle{}, rendering
|
||||
})
|
||||
if !errors.Is(err, delivery) || !errors.Is(err, rendering) {
|
||||
t.Fatalf("lost failure causes: %v", err)
|
||||
}
|
||||
for _, path := range session.ReportPaths() {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil || string(raw) != "initial" {
|
||||
t.Fatalf("report at %s: %s (%v)", path, raw, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type writerFunc func([]byte) (int, error)
|
||||
|
||||
func (write writerFunc) Write(payload []byte) (int, error) { return write(payload) }
|
||||
|
||||
func TestCancellationAfterStreamDeliveryUsesOnlyFailedReports(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
delivery := errors.New("late stream error")
|
||||
var escaped []byte
|
||||
session, err := PrepareOutput(OutputSelection{
|
||||
Stdout: writerFunc(func(payload []byte) (int, error) {
|
||||
escaped = append(escaped, payload...)
|
||||
cancel()
|
||||
return len(payload), delivery
|
||||
}),
|
||||
ReportDir: t.TempDir(), ReportingEnabled: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var attempts int
|
||||
session.replace = func(ctx context.Context, path string, payload []byte) error {
|
||||
attempts++
|
||||
if ctx.Err() != nil || string(payload) != "failed" {
|
||||
t.Errorf("unexpected publication for %s: %q, context %v", path, payload, ctx.Err())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
err = session.Finish(ctx, nil, []byte("transcript"), func(primary error, failures []FileFailure) (ReportBundle, error) {
|
||||
if !errors.Is(primary, context.Canceled) || len(failures) != 1 || !errors.Is(failures[0], delivery) {
|
||||
t.Fatalf("renderer received %v, %v", primary, failures)
|
||||
}
|
||||
return ReportBundle{Errors: []byte("failed"), Recoveries: []byte("failed"), Markdown: []byte("failed")}, nil
|
||||
})
|
||||
if string(escaped) != "transcript" || attempts != 3 || !errors.Is(err, context.Canceled) || !errors.Is(err, delivery) {
|
||||
t.Fatalf("escaped=%q reports=%d error=%v", escaped, attempts, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCleanupFailureKeepsTemporaryDirectoryForRetry(t *testing.T) {
|
||||
session, err := PrepareOutput(OutputSelection{TranscriptPath: filepath.Join(t.TempDir(), "output.json")})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tempDir := session.transcriptFile.dir
|
||||
extra := filepath.Join(tempDir, "extra")
|
||||
if err := os.WriteFile(extra, nil, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
primary := errors.New("processing failed")
|
||||
err = session.Finish(context.Background(), primary, nil, nil)
|
||||
var failure FileFailure
|
||||
if !errors.Is(err, primary) || !errors.As(err, &failure) || failure.Kind != "output cleanup" || session.transcriptFile.dir != tempDir {
|
||||
t.Fatalf("cleanup error=%v, directory=%q", err, session.transcriptFile.dir)
|
||||
}
|
||||
if err := os.Remove(extra); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := session.Close(); err != nil || session.transcriptFile.dir != "" {
|
||||
t.Fatalf("retry error=%v, directory=%q", err, session.transcriptFile.dir)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDebugRunDirectoryUsesSuppliedIDAndIsRetained(t *testing.T) {
|
||||
parent := filepath.Join(t.TempDir(), "debug")
|
||||
if _, err := os.Stat(parent); !errors.Is(err, os.ErrNotExist) {
|
||||
@@ -326,10 +509,10 @@ func TestSelectionAndAbortPreserveTranscript(t *testing.T) {
|
||||
if err := session.Prepare(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if session.temp == nil {
|
||||
if session.transcriptFile.file == nil {
|
||||
t.Fatal("temporary output not open")
|
||||
}
|
||||
temp := session.tempPath
|
||||
temp := session.transcriptFile.path
|
||||
if err := session.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -347,7 +530,7 @@ func TestStdoutAndDeviceDelivery(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if failures := session.Finalize([]byte("transcript"), ReportBundle{}, nil); len(failures) != 0 {
|
||||
if failures := session.finalize(context.Background(), nil, []byte("transcript"), nil); len(failures) != 0 {
|
||||
t.Fatal(failures)
|
||||
}
|
||||
if stdout.String() != "transcript" {
|
||||
@@ -357,10 +540,10 @@ func TestStdoutAndDeviceDelivery(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !session.direct || session.temp != nil {
|
||||
if !session.direct || session.transcriptFile.file != nil {
|
||||
t.Fatal("device was not deferred")
|
||||
}
|
||||
if failures := session.Finalize([]byte("discard"), ReportBundle{}, nil); len(failures) != 0 {
|
||||
if failures := session.finalize(context.Background(), nil, []byte("discard"), nil); len(failures) != 0 {
|
||||
t.Fatal(failures)
|
||||
}
|
||||
}
|
||||
@@ -376,15 +559,15 @@ func TestFinishRetainsPrimaryFailureAndAttemptsReports(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
originalReplace := session.replace
|
||||
session.replace = func(path string, data []byte) error {
|
||||
session.replace = func(ctx context.Context, path string, data []byte) error {
|
||||
if filepath.Base(path) == ErrorsFile {
|
||||
return os.ErrPermission
|
||||
}
|
||||
return originalReplace(path, data)
|
||||
return originalReplace(ctx, path, data)
|
||||
}
|
||||
primary := errors.New("processing failed")
|
||||
bundle := ReportBundle{Errors: []byte("failed"), Recoveries: []byte("failed"), Markdown: []byte("failed")}
|
||||
result := session.Finish(primary, []byte("unwanted"), bundle, func([]FileFailure) ReportBundle { return bundle })
|
||||
result := session.Finish(context.Background(), primary, []byte("unwanted"), func(error, []FileFailure) (ReportBundle, error) { return bundle, nil })
|
||||
if !errors.Is(result, primary) || !errors.Is(result, os.ErrPermission) {
|
||||
t.Fatalf("combined error: %v", result)
|
||||
}
|
||||
@@ -398,18 +581,14 @@ func TestFinishRetainsPrimaryFailureAndAttemptsReports(t *testing.T) {
|
||||
|
||||
func TestOptionalDebugPreparationReportsProblems(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
session, err := SelectOutput(OutputSelection{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
file := filepath.Join(dir, "not-directory")
|
||||
if err := os.WriteFile(file, []byte("x"), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if run, problems := session.PrepareDebug(file, "run", InvocationMetadata{}, nil); run != nil || len(problems) == 0 {
|
||||
if run, problems := PrepareDebug(file, "run", InvocationMetadata{}, nil); run != nil || len(problems) == 0 {
|
||||
t.Fatalf("run=%v problems=%v", run, problems)
|
||||
}
|
||||
run, problems := session.PrepareDebug(filepath.Join(dir, "debug"), "run", InvocationMetadata{Operation: "process"}, []byte("version: 3\n"))
|
||||
run, problems := PrepareDebug(filepath.Join(dir, "debug"), "run", InvocationMetadata{Operation: "process"}, []byte("version: 3\n"))
|
||||
if len(problems) != 0 {
|
||||
t.Fatal(problems)
|
||||
}
|
||||
@@ -431,7 +610,7 @@ func TestShortStdoutWriteIsFailure(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
failures := session.Finalize([]byte("transcript"), ReportBundle{}, nil)
|
||||
failures := session.finalize(context.Background(), nil, []byte("transcript"), nil)
|
||||
if len(failures) != 1 || !errors.Is(failures[0], io.ErrShortWrite) {
|
||||
t.Fatalf("failures=%v", failures)
|
||||
}
|
||||
@@ -447,11 +626,11 @@ func TestTranscriptWriteFailureCleansTemporaryResource(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
temp := session.tempPath
|
||||
if err := session.temp.Close(); err != nil {
|
||||
temp := session.transcriptFile.path
|
||||
if err := session.transcriptFile.file.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
failures := session.Finalize([]byte("new"), ReportBundle{}, nil)
|
||||
failures := session.finalize(context.Background(), nil, []byte("new"), nil)
|
||||
if len(failures) == 0 {
|
||||
t.Fatal("closed output accepted")
|
||||
}
|
||||
@@ -470,7 +649,7 @@ func TestNamedPipeIsNotOpenedDuringPreparation(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !session.direct || session.temp != nil {
|
||||
if !session.direct || session.transcriptFile.file != nil {
|
||||
t.Fatal("pipe was not deferred")
|
||||
}
|
||||
if err := session.Close(); err != nil {
|
||||
@@ -487,7 +666,7 @@ func TestLateNamedPipeIsPreserved(t *testing.T) {
|
||||
}
|
||||
defer session.Close()
|
||||
makeNamedPipe(t, path)
|
||||
err = session.Finish(nil, []byte("transcript"), ReportBundle{}, nil)
|
||||
err = session.Finish(context.Background(), nil, []byte("transcript"), nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "changed type") {
|
||||
t.Fatalf("expected clear delivery failure, got %v", err)
|
||||
}
|
||||
@@ -515,7 +694,7 @@ func TestStreamChangedToRegularFileIsPreserved(t *testing.T) {
|
||||
if err := os.WriteFile(path, []byte("existing content"), 0600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err = session.Finish(nil, []byte("new"), ReportBundle{}, nil)
|
||||
err = session.Finish(context.Background(), nil, []byte("new"), nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "no longer a stream") {
|
||||
t.Fatalf("expected clear delivery failure, got %v", err)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user