255 lines
10 KiB
Go
255 lines
10 KiB
Go
package protocol
|
|
|
|
import "strings"
|
|
|
|
type RunAutonomousLifecyclePlan struct {
|
|
SchemaVersion string `json:"schemaVersion"`
|
|
ServerInstanceID string `json:"serverInstanceId"`
|
|
PluginID string `json:"pluginId"`
|
|
PluginVersion string `json:"pluginVersion"`
|
|
RunEndpointID string `json:"runEndpointId"`
|
|
ProfileKey string `json:"profileKey,omitempty"`
|
|
TargetOS string `json:"targetOs"`
|
|
TargetArch string `json:"targetArch"`
|
|
TargetRelease string `json:"targetRelease"`
|
|
DeploymentRevision int `json:"deploymentRevision,omitempty"`
|
|
Bootstrap *RunAutonomousLifecycleAction `json:"bootstrap,omitempty"`
|
|
Actions []RunAutonomousLifecycleAction `json:"actions,omitempty"`
|
|
DependencyProbes []DependencyProbe `json:"dependencyProbes,omitempty"`
|
|
InstallPlans []DependencyInstallPlan `json:"installPlans,omitempty"`
|
|
LogSources []RuntimeLogSourcePlan `json:"logSources,omitempty"`
|
|
DLLExtensions []RuntimeDLLExtensionPlan `json:"dllExtensions,omitempty"`
|
|
DataTargets []RunAutonomousDataTarget `json:"dataTargets,omitempty"`
|
|
RuntimeBindings map[string]string `json:"runtimeBindings,omitempty"`
|
|
Deployment *RunAutonomousDeployment `json:"deployment,omitempty"`
|
|
}
|
|
|
|
type RunAutonomousLifecycleAction struct {
|
|
Action string `json:"action"`
|
|
Operation string `json:"operation"`
|
|
Capability string `json:"capability"`
|
|
TargetKey string `json:"targetKey"`
|
|
}
|
|
|
|
type RunAutonomousDeployment struct {
|
|
SchemaVersion string `json:"schemaVersion"`
|
|
Mode string `json:"mode"`
|
|
ProfileKey string `json:"profileKey,omitempty"`
|
|
RuntimeBindings map[string]string `json:"runtimeBindings,omitempty"`
|
|
CreateInputs map[string]string `json:"createInputs,omitempty"`
|
|
ServerRoot string `json:"serverRoot,omitempty"`
|
|
WorkingDirectory string `json:"workingDirectory,omitempty"`
|
|
InstallCommand string `json:"installCommand,omitempty"`
|
|
StartCommand string `json:"startCommand,omitempty"`
|
|
StopCommand string `json:"stopCommand,omitempty"`
|
|
StatusCommand string `json:"statusCommand,omitempty"`
|
|
Shell string `json:"shell,omitempty"`
|
|
Revision int `json:"revision,omitempty"`
|
|
}
|
|
|
|
type RunAutonomousDataTarget struct {
|
|
Key string `json:"key"`
|
|
Kind string `json:"kind"`
|
|
TransportKey string `json:"transportKey"`
|
|
SourceRootKey string `json:"sourceRootKey"`
|
|
SourcePath string `json:"sourcePath"`
|
|
WorkspaceKey string `json:"workspaceKey"`
|
|
RefreshPolicy string `json:"refreshPolicy"`
|
|
MaxBytes int64 `json:"maxBytes,omitempty"`
|
|
Platforms []string `json:"platforms,omitempty"`
|
|
}
|
|
|
|
const maxAutonomousDataTargetBytes = int64(1024 * 1024 * 1024)
|
|
|
|
func ValidateRunAutonomousLifecyclePlan(plan RunAutonomousLifecyclePlan) error {
|
|
if plan.SchemaVersion != "1" {
|
|
return ValidationError("autonomous lifecycle plan schema is unsupported")
|
|
}
|
|
if !ValidLogicalFileKey(plan.ServerInstanceID) || !ValidLogicalFileKey(plan.RunEndpointID) || !validAutonomousPluginID(plan.PluginID) {
|
|
return ValidationError("autonomous lifecycle plan identity is invalid")
|
|
}
|
|
if plan.ProfileKey != "" && !ValidLogicalFileKey(plan.ProfileKey) {
|
|
return ValidationError("autonomous lifecycle profile key is invalid")
|
|
}
|
|
if !validAutonomousTarget(plan.TargetOS, plan.TargetArch) {
|
|
return ValidationError("autonomous lifecycle target platform is invalid")
|
|
}
|
|
if plan.TargetRelease != "" && !validAutonomousToken(plan.TargetRelease, 240) {
|
|
return ValidationError("autonomous lifecycle target release is invalid")
|
|
}
|
|
if plan.PluginVersion != "" && !validAutonomousToken(plan.PluginVersion, 120) {
|
|
return ValidationError("autonomous lifecycle plugin version is invalid")
|
|
}
|
|
if plan.Bootstrap != nil {
|
|
if err := validateAutonomousLifecycleAction(*plan.Bootstrap); err != nil {
|
|
return err
|
|
}
|
|
if plan.Bootstrap.Capability != RunCapabilityProcessInstall && plan.Bootstrap.Capability != RunCapabilityProcessStart {
|
|
return ValidationError("autonomous lifecycle bootstrap action is invalid")
|
|
}
|
|
}
|
|
if len(plan.Actions) > 16 || len(plan.DependencyProbes) > 64 || len(plan.InstallPlans) > 64 || len(plan.LogSources) > 16 || len(plan.DLLExtensions) > 16 || len(plan.DataTargets) > 16 {
|
|
return ValidationError("autonomous lifecycle plan is too large")
|
|
}
|
|
for _, action := range plan.Actions {
|
|
if err := validateAutonomousLifecycleAction(action); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, probe := range plan.DependencyProbes {
|
|
if !ValidLogicalFileKey(probe.Key) || !ValidLogicalFileKey(probe.TargetKey) || !validAutonomousToken(probe.Kind, 80) || probe.MinimumVersion != "" && !validAutonomousToken(probe.MinimumVersion, 80) {
|
|
return ValidationError("autonomous dependency probe is invalid")
|
|
}
|
|
}
|
|
for _, installPlan := range plan.InstallPlans {
|
|
if !ValidLogicalFileKey(installPlan.Key) || len(installPlan.Steps) > 64 {
|
|
return ValidationError("autonomous install plan is invalid")
|
|
}
|
|
for _, step := range installPlan.Steps {
|
|
if !ValidLogicalFileKey(step.TargetKey) || !validAutonomousToken(step.Type, 80) || step.PackageManager != "" && !validAutonomousToken(step.PackageManager, 80) || step.PackageName != "" && !validAutonomousToken(step.PackageName, 160) || step.Version != "" && !validAutonomousToken(step.Version, 120) {
|
|
return ValidationError("autonomous install step is invalid")
|
|
}
|
|
}
|
|
}
|
|
for _, source := range plan.LogSources {
|
|
if err := validateRuntimeProcessLogSourcePlan(source); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
seenDataTargets := map[string]struct{}{}
|
|
seenWorkspaceTargets := map[string]struct{}{}
|
|
for _, target := range plan.DataTargets {
|
|
if err := validateAutonomousDataTarget(target); err != nil {
|
|
return err
|
|
}
|
|
if _, exists := seenDataTargets[target.Key]; exists {
|
|
return ValidationError("autonomous data target key is duplicated")
|
|
}
|
|
if _, exists := seenWorkspaceTargets[target.WorkspaceKey]; exists {
|
|
return ValidationError("autonomous data target workspace is duplicated")
|
|
}
|
|
seenDataTargets[target.Key] = struct{}{}
|
|
seenWorkspaceTargets[target.WorkspaceKey] = struct{}{}
|
|
}
|
|
if plan.Deployment != nil {
|
|
if err := validateAutonomousDeployment(*plan.Deployment); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateAutonomousDataTarget(target RunAutonomousDataTarget) error {
|
|
if !ValidLogicalFileKey(target.Key) || !ValidLogicalFileKey(target.TransportKey) || !ValidLogicalFileKey(target.SourceRootKey) || !ValidLogicalFileKey(target.SourcePath) || !ValidLogicalFileKey(target.WorkspaceKey) {
|
|
return ValidationError("autonomous data target is invalid")
|
|
}
|
|
if target.Kind != "sqlite.snapshot" || target.RefreshPolicy != "on-demand-snapshot" || !strings.HasPrefix(target.WorkspaceKey, "databases/") {
|
|
return ValidationError("autonomous data target is invalid")
|
|
}
|
|
if target.MaxBytes <= 0 || target.MaxBytes > maxAutonomousDataTargetBytes {
|
|
return ValidationError("autonomous data target byte limit is invalid")
|
|
}
|
|
for _, platform := range target.Platforms {
|
|
if platform != "windows" && platform != "linux" && platform != "darwin" {
|
|
return ValidationError("autonomous data target platform is invalid")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateAutonomousLifecycleAction(action RunAutonomousLifecycleAction) error {
|
|
if !ValidLogicalFileKey(action.TargetKey) || !validAutonomousLifecycleCapability(action.Capability) || !validAutonomousLifecycleName(action.Action) || !validAutonomousLifecycleName(action.Operation) {
|
|
return ValidationError("autonomous lifecycle action is invalid")
|
|
}
|
|
if expected := autonomousCapabilityForAction(action.Action); expected != "" && expected != action.Capability {
|
|
return ValidationError("autonomous lifecycle action capability mismatch")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func autonomousCapabilityForAction(action string) string {
|
|
switch action {
|
|
case "create":
|
|
return RunCapabilityProcessInstall
|
|
case "start":
|
|
return RunCapabilityProcessStart
|
|
case "stop":
|
|
return RunCapabilityProcessStop
|
|
case "status":
|
|
return RunCapabilityProcessStatus
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func validAutonomousLifecycleCapability(capability string) bool {
|
|
switch capability {
|
|
case RunCapabilityProcessInstall, RunCapabilityProcessStart, RunCapabilityProcessStop, RunCapabilityProcessStatus:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func validAutonomousLifecycleName(value string) bool {
|
|
switch value {
|
|
case "create", "install", "start", "stop", "status":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func validateAutonomousDeployment(deployment RunAutonomousDeployment) error {
|
|
if deployment.SchemaVersion != "1" || deployment.Mode == "" || deployment.Revision < 0 || deployment.ProfileKey != "" && !ValidLogicalFileKey(deployment.ProfileKey) {
|
|
return ValidationError("autonomous deployment is invalid")
|
|
}
|
|
for key := range deployment.RuntimeBindings {
|
|
if !ValidLogicalFileKey(key) {
|
|
return ValidationError("autonomous deployment binding is invalid")
|
|
}
|
|
}
|
|
for key := range deployment.CreateInputs {
|
|
if !ValidLogicalFileKey(key) {
|
|
return ValidationError("autonomous deployment input is invalid")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validAutonomousPluginID(value string) bool {
|
|
return ValidLogicalFileKey(value)
|
|
}
|
|
|
|
func validAutonomousTarget(osName string, arch string) bool {
|
|
switch osName {
|
|
case "windows", "linux", "darwin":
|
|
default:
|
|
return false
|
|
}
|
|
switch arch {
|
|
case "amd64", "arm64":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func validAutonomousToken(value string, maxRunes int) bool {
|
|
trimmed := strings.TrimSpace(value)
|
|
if trimmed == "" || trimmed != value || len([]rune(value)) > maxRunes {
|
|
return false
|
|
}
|
|
lower := strings.ToLower(value)
|
|
if strings.Contains(value, "..") || strings.Contains(value, `\`) || strings.Contains(value, "://") || strings.Contains(lower, "/users/") || strings.Contains(lower, "password=") || strings.Contains(lower, "secret=") || strings.Contains(lower, "bearer ") || strings.Contains(lower, "sk-") {
|
|
return false
|
|
}
|
|
for _, char := range value {
|
|
if char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char >= '0' && char <= '9' || char == '_' || char == '-' || char == '.' || char == '/' || char == ':' {
|
|
continue
|
|
}
|
|
return false
|
|
}
|
|
return true
|
|
}
|