Remove legacy client-manager platform path

2026-09-03 16:40:05 +08:00
parent ec2462a312
commit 80cddbf19d
51 changed files with 382 additions and 4271 deletions
@@ -115,158 +115,6 @@ func (svc *CoreService) GenerateRunDistributionForSession(sessionID string, requ
 	return domain.CopyRunDistribution(distribution), nil
 }

-func (svc *CoreService) GenerateClientManagerDistributionForSession(sessionID string, request domain.ClientManagerBuildRequest) (domain.ClientManagerDistribution, error) {
-	return domain.ClientManagerDistribution{}, legacyClientManagerUnsupported()
-
-	request = domain.CopyClientManagerBuildRequest(request)
-	if strings.TrimSpace(request.IdempotencyKey) == "" {
-		request.IdempotencyKey = "client-manager-" + request.ServerInstanceID + "-" + request.ProfileKey + "-" + request.TargetOS + "-" + request.TargetArch
-	}
-	if err := validator.ValidateClientManagerBuildRequest(request); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	user, err := svc.GetCurrentUser(sessionID)
-	if err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	instance, err := svc.GetServerInstanceForSession(sessionID, request.ServerInstanceID)
-	if err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	plugin, err := svc.store.GamePlugins().Get(instance.PluginID)
-	if err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	if err := svc.validateDistributionPluginPermission(user.ID, plugin, instance.ID, "server.client-manager.manage", "client-manager.build.denied"); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	if err := validatePluginTarget(plugin, request.TargetOS); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	profile, err := findRuntimeClientManagerProfile(plugin, request.ProfileKey)
-	if err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	if strings.TrimSpace(request.SourceRevision) == "" {
-		request.SourceRevision = clientManagerProfileRevision(profile)
-	}
-	if !clientManagerProfileSupportsTarget(profile, request.TargetOS, request.TargetArch) || request.RepositoryURL != profile.RepositoryURL || !clientManagerProfileAllowsRevision(profile, request.SourceRevision) {
-		return domain.ClientManagerDistribution{}, validationError("client-manager build must match the declared profile repository, revision, and target")
-	}
-	if err := svc.requireCompleteRuntimeBindings(user.ID, instance.ID, "client-manager.build.denied"); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	if ready, reason := svc.distributionBuilderReadiness(); !ready {
-		return domain.ClientManagerDistribution{}, validationError(reason)
-	}
-
-	key, _, err := svc.ensureActiveComponentKey(instance.ID, domain.DistributionComponentClientManager, request.ProfileKey)
-	if err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	clientDistributionID := distributionID("client-manager-dist", instance.ID, request.ProfileKey, request.TargetOS, request.TargetArch, key.Generation, request.IdempotencyKey)
-	if existing, err := svc.store.ClientManagerDistributions().Get(clientDistributionID); err == nil {
-		return domain.CopyClientManagerDistribution(existing), nil
-	} else if !errors.Is(err, repo.ErrNotFound) {
-		return domain.ClientManagerDistribution{}, err
-	}
-
-	artifactID := artifactIDForDistribution(clientDistributionID + "-binary")
-	stamp := svc.now()
-	buildJobID := jobIDFromParts("job-distribution-build", instance.ID, clientDistributionID)
-	buildJob := domain.ClientManagerBuildJob{
-		ID:               buildJobID,
-		ServerInstanceID: instance.ID,
-		PluginID:         plugin.ID,
-		ProfileKey:       request.ProfileKey,
-		Version:          profile.Version,
-		TargetOS:         request.TargetOS,
-		TargetArch:       request.TargetArch,
-		RepositoryURL:    request.RepositoryURL,
-		SourceRevision:   request.SourceRevision,
-		ArtifactID:       artifactID,
-		KeyGeneration:    key.Generation,
-		Status:           domain.DistributionJobStatusQueued,
-		CreatedAt:        stamp,
-		UpdatedAt:        stamp,
-	}
-	if err := validator.ValidateClientManagerBuildJob(buildJob); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	if err := svc.store.ClientManagerBuildJobs().Create(buildJob); err != nil {
-		if !errors.Is(err, repo.ErrDuplicate) {
-			return domain.ClientManagerDistribution{}, err
-		}
-		existing, getErr := svc.store.ClientManagerBuildJobs().Get(buildJob.ID)
-		if getErr != nil {
-			return domain.ClientManagerDistribution{}, getErr
-		}
-		if !sameClientManagerBuildJobArtifacts(existing, buildJob) {
-			return domain.ClientManagerDistribution{}, validationError("client-manager build job already exists with different artifacts")
-		}
-		buildJob = existing
-	}
-	distribution := domain.ClientManagerDistribution{
-		ID:               clientDistributionID,
-		ServerInstanceID: instance.ID,
-		PluginID:         plugin.ID,
-		ProfileKey:       request.ProfileKey,
-		Version:          profile.Version,
-		TargetOS:         request.TargetOS,
-		TargetArch:       request.TargetArch,
-		RepositoryURL:    request.RepositoryURL,
-		SourceRevision:   request.SourceRevision,
-		BuildJobID:       buildJob.ID,
-		ArtifactID:       artifactID,
-		KeyGeneration:    key.Generation,
-		SecretRef:        key.SecretRef,
-		Status:           domain.DistributionStatusBuilding,
-		CreatedAt:        stamp,
-		UpdatedAt:        stamp,
-	}
-	if err := validator.ValidateClientManagerDistribution(distribution); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	if err := svc.store.ClientManagerDistributions().Create(distribution); err != nil {
-		if errors.Is(err, repo.ErrDuplicate) {
-			existing, getErr := svc.store.ClientManagerDistributions().Get(distribution.ID)
-			if getErr != nil {
-				return domain.ClientManagerDistribution{}, getErr
-			}
-			return domain.CopyClientManagerDistribution(existing), nil
-		}
-		return domain.ClientManagerDistribution{}, err
-	}
-	if err := svc.ProjectClientManagerDistribution(distribution); err != nil {
-		return domain.ClientManagerDistribution{}, err
-	}
-	job, err := svc.CreateJob(domain.Job{
-		ID:               buildJobID,
-		ServerInstanceID: instance.ID,
-		RunEndpointID:    platformDistributionBuilderEndpointID,
-		Capability:       domain.JobCapabilityDistributionBuild,
-		TargetKey:        "distribution/client-manager/" + request.ProfileKey,
-		InputRef:         "input://distribution-build/" + distribution.ID,
-		IdempotencyKey:   "distribution-build:" + distribution.ID,
-		Progress:         domain.JobProgress{Percent: 0, Message: "build queued"},
-	})
-	if err != nil {
-		buildJob.Status = domain.DistributionJobStatusFailed
-		buildJob.UpdatedAt = svc.now()
-		distribution.Status = domain.DistributionStatusFailed
-		distribution.UpdatedAt = buildJob.UpdatedAt
-		_ = svc.store.ClientManagerBuildJobs().Update(buildJob)
-		_ = svc.store.ClientManagerDistributions().Update(distribution)
-		_ = svc.ProjectClientManagerDistribution(distribution)
-		return domain.ClientManagerDistribution{}, err
-	}
-	if job.ID != buildJobID || job.Capability != domain.JobCapabilityDistributionBuild {
-		return domain.ClientManagerDistribution{}, validationError("distribution build idempotency key conflicts with another job")
-	}
-	svc.enqueueDistributionBuild(job)
-	return domain.CopyClientManagerDistribution(distribution), nil
-}
-
 func (svc *CoreService) OpenLatestRunDistributionDownloadForSession(sessionID string, serverInstanceID string) (domain.ArtifactDownloadReference, error) {
 	instance, err := svc.GetServerInstanceForSession(sessionID, serverInstanceID)
 	if err != nil {
@@ -288,33 +136,6 @@ func (svc *CoreService) OpenLatestRunDistributionDownloadForSession(sessionID st
 	return svc.OpenArtifactDownloadForSession(sessionID, domain.ArtifactDownloadReferenceRequest{ArtifactID: latest.ArtifactID})
 }

-func (svc *CoreService) OpenLatestClientManagerDistributionDownloadForSession(sessionID string, serverInstanceID string, profileKey string) (domain.ArtifactDownloadReference, error) {
-	return domain.ArtifactDownloadReference{}, legacyClientManagerUnsupported()
-
-	instance, err := svc.GetServerInstanceForSession(sessionID, serverInstanceID)
-	if err != nil {
-		return domain.ArtifactDownloadReference{}, err
-	}
-	filter := domain.ClientManagerDistributionFilter{ServerInstanceID: instance.ID, Status: domain.DistributionStatusAvailable}
-	if strings.TrimSpace(profileKey) != "" {
-		filter.ProfileKey = strings.TrimSpace(profileKey)
-	}
-	distributions, err := svc.store.ClientManagerDistributions().List(filter)
-	if err != nil {
-		return domain.ArtifactDownloadReference{}, err
-	}
-	var latest domain.ClientManagerDistribution
-	for _, distribution := range distributions {
-		if latest.ID == "" || distribution.KeyGeneration > latest.KeyGeneration || (distribution.KeyGeneration == latest.KeyGeneration && distribution.UpdatedAt.After(latest.UpdatedAt)) {
-			latest = distribution
-		}
-	}
-	if latest.ID == "" {
-		return domain.ArtifactDownloadReference{}, repo.ErrNotFound
-	}
-	return svc.OpenArtifactDownloadForSession(sessionID, domain.ArtifactDownloadReferenceRequest{ArtifactID: latest.ArtifactID})
-}
-
 func (svc *CoreService) ResetComponentKeyForSession(sessionID string, request domain.ComponentKeyResetRequest) (domain.EncryptedComponentKey, error) {
 	request = domain.CopyComponentKeyResetRequest(request)
 	if err := validator.ValidateComponentKeyResetRequest(request); err != nil {
@@ -810,27 +631,6 @@ func (svc *CoreService) revokeComponentDistributions(serverInstanceID string, ki
 				return err
 			}
 		}
-	case domain.DistributionComponentClientManager:
-		distributions, err := svc.store.ClientManagerDistributions().List(domain.ClientManagerDistributionFilter{ServerInstanceID: serverInstanceID, ProfileKey: componentKey})
-		if err != nil {
-			return err
-		}
-		for _, distribution := range distributions {
-			if distribution.KeyGeneration >= latestGeneration || distribution.Status == domain.DistributionStatusRevoked {
-				continue
-			}
-			distribution.Status = domain.DistributionStatusRevoked
-			distribution.UpdatedAt = svc.now()
-			if err := validator.ValidateClientManagerDistribution(distribution); err != nil {
-				return err
-			}
-			if err := svc.store.ClientManagerDistributions().Update(distribution); err != nil {
-				return err
-			}
-			if err := svc.expireDistributionArtifact(distribution.ArtifactID); err != nil {
-				return err
-			}
-		}
 	}
 	return nil
 }
@@ -929,22 +729,6 @@ func (svc *CoreService) ensureArtifactPayload(artifactID string, payload []byte,
 	return nil
 }

-func sameClientManagerBuildJobArtifacts(existing domain.ClientManagerBuildJob, expected domain.ClientManagerBuildJob) bool {
-	return existing.ServerInstanceID == expected.ServerInstanceID &&
-		existing.PluginID == expected.PluginID &&
-		existing.ProfileKey == expected.ProfileKey &&
-		existing.Version == expected.Version &&
-		existing.TargetOS == expected.TargetOS &&
-		existing.TargetArch == expected.TargetArch &&
-		existing.RepositoryURL == expected.RepositoryURL &&
-		existing.SourceRevision == expected.SourceRevision &&
-		existing.ArtifactID == expected.ArtifactID &&
-		existing.Checksum == expected.Checksum &&
-		existing.KeyGeneration == expected.KeyGeneration &&
-		existing.LogsRef == expected.LogsRef &&
-		existing.Status == expected.Status
-}
-
 func (svc *CoreService) upsertDependencyStatus(instance domain.ServerInstance, request domain.DependencyJobRequest, jobID string, required bool, state domain.DependencyState, message string) error {
 	statusID := distributionID("dependency-status", instance.ID, request.ProbeKey)
 	stamp := svc.now()
@@ -1070,14 +854,6 @@ func fingerprintForString(value string) string {
 	return hex.EncodeToString(sum[:])[:12]
 }

-func clientManagerOutputName(profileKey string, targetOS string) string {
-	name := sanitizeIDPart(profileKey)
-	if targetOS == "windows" {
-		return name + ".exe"
-	}
-	return name
-}
-
 func minInt(a int, b int) int {
 	if a < b {
 		return a