243 lines
10 KiB
Go
243 lines
10 KiB
Go
package validator
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"browser.local/platform/domain"
|
|
)
|
|
|
|
const maxJobChannelMessageLength = 256
|
|
|
|
func ValidateRunJobClaim(claim domain.RunJobClaim) error {
|
|
var violations []string
|
|
violations = appendRequired(violations, "runEndpointId", claim.RunEndpointID)
|
|
violations = appendRequired(violations, "sessionToken", claim.SessionToken)
|
|
violations = appendCapacityViolations(violations, claim.Capacity)
|
|
for i, capability := range claim.Capabilities {
|
|
if strings.TrimSpace(capability) == "" {
|
|
violations = append(violations, fmt.Sprintf("capabilities[%d] is required", i))
|
|
}
|
|
}
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunJobAck(ack domain.RunJobAck) error {
|
|
var violations []string
|
|
violations = appendLeaseFields(violations, ack.RunEndpointID, ack.SessionToken, ack.JobID, ack.LeaseToken, ack.Attempt)
|
|
violations = appendMessageLength(violations, "message", ack.Message)
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunJobProgress(progress domain.RunJobProgress) error {
|
|
var violations []string
|
|
violations = appendLeaseFields(violations, progress.RunEndpointID, progress.SessionToken, progress.JobID, progress.LeaseToken, progress.Attempt)
|
|
violations = appendProgressViolations(violations, progress.Progress)
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunJobResult(result domain.RunJobResult) error {
|
|
var violations []string
|
|
violations = appendLeaseFields(violations, result.RunEndpointID, result.SessionToken, result.JobID, result.LeaseToken, result.Attempt)
|
|
if !validTerminalJobState(result.State) {
|
|
violations = append(violations, "state must be succeeded, failed, or cancelled")
|
|
}
|
|
violations = appendProgressViolations(violations, result.Progress)
|
|
violations = appendMessageLength(violations, "message", result.Message)
|
|
violations = appendMessageLength(violations, "errorCode", result.ErrorCode)
|
|
if len([]byte(result.ExecutionResult.Content)) > maxJobChannelMessageLength*256 {
|
|
violations = append(violations, "executionResult.content is too large")
|
|
}
|
|
if result.ExecutionResult.Checksum != "" && !validSHA256Checksum(result.ExecutionResult.Checksum) {
|
|
violations = append(violations, "executionResult.checksum must be sha256:<hex>")
|
|
}
|
|
if result.ExecutionResult.SQLiteSchemaProbe != nil {
|
|
if err := ValidateSCUMSchemaProbeResult(*result.ExecutionResult.SQLiteSchemaProbe); err != nil {
|
|
violations = append(violations, "executionResult.sqliteSchemaProbe: "+err.Error())
|
|
}
|
|
}
|
|
if result.ExecutionResult.SQLiteTemplate != nil {
|
|
if err := ValidateSCUMSQLiteTemplateResult(*result.ExecutionResult.SQLiteTemplate); err != nil {
|
|
violations = append(violations, "executionResult.sqliteTemplate: "+err.Error())
|
|
}
|
|
}
|
|
if result.ExecutionResult.RCONTemplate != nil {
|
|
if err := ValidateSCUMTypedRCONTemplateResult(*result.ExecutionResult.RCONTemplate); err != nil {
|
|
violations = append(violations, "executionResult.rconTemplate: "+err.Error())
|
|
}
|
|
}
|
|
if result.ExecutionResult.GuardedMutation != nil {
|
|
if err := ValidateSCUMGuardedMutationResult(*result.ExecutionResult.GuardedMutation); err != nil {
|
|
violations = append(violations, "executionResult.guardedMutation: "+err.Error())
|
|
}
|
|
}
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunLifecycleReport(report domain.RunLifecycleReport) error {
|
|
var violations []string
|
|
violations = appendRequired(violations, "runEndpointId", report.RunEndpointID)
|
|
violations = appendRequired(violations, "sessionToken", report.SessionToken)
|
|
violations = appendRequired(violations, "serverInstanceId", report.ServerInstanceID)
|
|
violations = appendRequired(violations, "capability", report.Capability)
|
|
if !validLifecycleReportCapability(report.Capability) {
|
|
violations = append(violations, "capability must be process.install, process.start, process.stop, or process.status")
|
|
}
|
|
if !validTerminalJobState(report.State) {
|
|
violations = append(violations, "state must be succeeded, failed, or cancelled")
|
|
}
|
|
violations = appendProgressViolations(violations, report.Progress)
|
|
violations = appendMessageLength(violations, "message", report.Message)
|
|
violations = appendMessageLength(violations, "errorCode", report.ErrorCode)
|
|
if report.ManagedProcessID != "" && report.ObservationSeq == 0 {
|
|
violations = append(violations, "observationSeq is required with managedProcessId")
|
|
}
|
|
if report.ObservationSeq > 0 && report.ManagedProcessID == "" {
|
|
violations = append(violations, "managedProcessId is required with observationSeq")
|
|
}
|
|
if len([]byte(report.ExecutionResult.Content)) > maxJobChannelMessageLength*256 {
|
|
violations = append(violations, "executionResult.content is too large")
|
|
}
|
|
if report.ExecutionResult.Checksum != "" && !validSHA256Checksum(report.ExecutionResult.Checksum) {
|
|
violations = append(violations, "executionResult.checksum must be sha256:<hex>")
|
|
}
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateDistributionBuildInputRequest(request domain.DistributionBuildInputRequest) error {
|
|
var violations []string
|
|
violations = appendLeaseFields(violations, request.RunEndpointID, request.SessionToken, request.JobID, request.LeaseToken, request.Attempt)
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateDependencyExecutionInputRequest(request domain.DependencyExecutionInputRequest) error {
|
|
return finish(appendLeaseFields(nil, request.RunEndpointID, request.SessionToken, request.JobID, request.LeaseToken, request.Attempt))
|
|
}
|
|
|
|
func ValidateSourceRCONExecutionInputRequest(request domain.SourceRCONExecutionInputRequest) error {
|
|
return finish(appendLeaseFields(nil, request.RunEndpointID, request.SessionToken, request.JobID, request.LeaseToken, request.Attempt))
|
|
}
|
|
|
|
func ValidateProtectedRequestExecutionInputRequest(request domain.ProtectedRequestExecutionInputRequest) error {
|
|
violations := appendLeaseFields(nil, request.RunEndpointID, request.SessionToken, request.JobID, request.LeaseToken, request.Attempt)
|
|
if request.FencingToken == 0 {
|
|
violations = append(violations, "fencingToken is required")
|
|
}
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunUpdateInputRequest(request domain.RunUpdateInputRequest) error {
|
|
return finish(appendLeaseFields(nil, request.RunEndpointID, request.SessionToken, request.JobID, request.LeaseToken, request.Attempt))
|
|
}
|
|
|
|
func ValidateRunUpdateChunkRequest(request domain.RunUpdateChunkRequest) error {
|
|
violations := appendLeaseFields(nil, request.RunEndpointID, request.SessionToken, request.JobID, request.LeaseToken, request.Attempt)
|
|
if request.Offset < 0 {
|
|
violations = append(violations, "offset must not be negative")
|
|
}
|
|
if request.Length <= 0 || request.Length > 1024*1024 {
|
|
violations = append(violations, "length must be between 1 and 1048576")
|
|
}
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunUpdateHealthReport(report domain.RunUpdateHealthReport) error {
|
|
violations := appendLeaseFields(nil, report.RunEndpointID, report.SessionToken, report.JobID, report.LeaseToken, report.Attempt)
|
|
if report.Outcome != "succeeded" && report.Outcome != "rolled-back" {
|
|
violations = append(violations, "outcome must be succeeded or rolled-back")
|
|
}
|
|
violations = appendRequired(violations, "version", report.Version)
|
|
violations = appendMessageLength(violations, "version", report.Version)
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunJobCancelRequest(request domain.RunJobCancelRequest) error {
|
|
var violations []string
|
|
violations = appendRequired(violations, "jobId", request.JobID)
|
|
violations = appendRequired(violations, "reason", request.Reason)
|
|
violations = appendMessageLength(violations, "reason", request.Reason)
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunJobCancelPoll(poll domain.RunJobCancelPoll) error {
|
|
var violations []string
|
|
violations = appendLeaseFields(violations, poll.RunEndpointID, poll.SessionToken, poll.JobID, poll.LeaseToken, poll.Attempt)
|
|
return finish(violations)
|
|
}
|
|
|
|
func ValidateRunJobReconcile(reconcile domain.RunJobReconcile) error {
|
|
var violations []string
|
|
violations = appendRequired(violations, "runEndpointId", reconcile.RunEndpointID)
|
|
violations = appendRequired(violations, "sessionToken", reconcile.SessionToken)
|
|
seen := map[string]struct{}{}
|
|
for i, entry := range reconcile.ActiveJobs {
|
|
prefix := fmt.Sprintf("activeJobs[%d]", i)
|
|
violations = appendRequired(violations, prefix+".jobId", entry.JobID)
|
|
violations = appendRequired(violations, prefix+".leaseToken", entry.LeaseToken)
|
|
if entry.Attempt <= 0 {
|
|
violations = append(violations, prefix+".attempt must be positive")
|
|
}
|
|
if _, exists := seen[entry.JobID]; exists {
|
|
violations = append(violations, fmt.Sprintf("%s duplicates %q", prefix, entry.JobID))
|
|
}
|
|
seen[entry.JobID] = struct{}{}
|
|
}
|
|
return finish(violations)
|
|
}
|
|
|
|
func appendLeaseFields(violations []string, runEndpointID string, sessionToken string, jobID string, leaseToken string, attempt int) []string {
|
|
violations = appendRequired(violations, "runEndpointId", runEndpointID)
|
|
violations = appendRequired(violations, "sessionToken", sessionToken)
|
|
violations = appendRequired(violations, "jobId", jobID)
|
|
violations = appendRequired(violations, "leaseToken", leaseToken)
|
|
if attempt <= 0 {
|
|
violations = append(violations, "attempt must be positive")
|
|
}
|
|
return violations
|
|
}
|
|
|
|
func appendProgressViolations(violations []string, progress domain.RunJobProgressReport) []string {
|
|
if progress.Percent < 0 || progress.Percent > 100 {
|
|
violations = append(violations, "progress.percent must be between 0 and 100")
|
|
}
|
|
if progress.Phase != "" && !validDeploymentProgressPhase(progress.Phase) {
|
|
violations = append(violations, "progress.phase is invalid")
|
|
}
|
|
violations = appendMessageLength(violations, "progress.message", progress.Message)
|
|
return violations
|
|
}
|
|
|
|
func validDeploymentProgressPhase(phase string) bool {
|
|
switch phase {
|
|
case "queued", "claimed", "preflight", "install", "configure", "start", "stop", "status", "health":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func appendMessageLength(violations []string, field string, message string) []string {
|
|
if len(message) > maxJobChannelMessageLength {
|
|
violations = append(violations, field+" is too long")
|
|
}
|
|
return violations
|
|
}
|
|
|
|
func validTerminalJobState(state domain.JobState) bool {
|
|
switch state {
|
|
case domain.JobStateSucceeded, domain.JobStateFailed, domain.JobStateCancelled:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func validLifecycleReportCapability(capability string) bool {
|
|
switch capability {
|
|
case domain.LifecycleCapabilityInstall, domain.LifecycleCapabilityStart, domain.LifecycleCapabilityStop, domain.LifecycleCapabilityStatus:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|