deploy static method

Future<void> deploy(
  1. Client cloudApiClient,
  2. FileUploaderFactory fileUploaderFactory, {
  3. required CommandLogger logger,
  4. required String baseCommand,
  5. required String projectId,
  6. required String projectDir,
  7. required String projectConfigFilePath,
  8. required int concurrency,
  9. required bool wetRun,
  10. required bool showFiles,
  11. bool skipDartPubGet = false,
  12. bool skipTailingStatus = false,
  13. bool suppressCommandMessages = false,
  14. String? outputPath,
  15. String? dartVersionOverride,
  16. IOSink? stdout,
  17. IOSink? stderr,
})

Implementation

static Future<void> deploy(
  Client cloudApiClient,
  FileUploaderFactory fileUploaderFactory, {
  required CommandLogger logger,
  required String baseCommand,
  required String projectId,
  required String projectDir,
  required String projectConfigFilePath,
  required int concurrency,
  required bool wetRun,
  required bool showFiles,
  bool skipDartPubGet = false,
  bool skipTailingStatus = false,
  bool suppressCommandMessages = false,
  String? outputPath,
  String? dartVersionOverride,
  IOSink? stdout,
  IOSink? stderr,
}) async {
  if (!suppressCommandMessages) {
    logger.init('Deploying Serverpod Cloud project "$projectId".');
  }

  final projectDirectory = Directory(projectDir);

  final supportedSdkVersions = await fetchSupportedDartSdkVersions(
    cloudApiClient,
  );

  final pubspecValidator = TenantProjectPubspec.fromProjectDir(
    projectDirectory,
  );

  final pubspecIssues = pubspecValidator.projectDependencyIssues();
  if (pubspecIssues.isNotEmpty) {
    throw FailureException(errors: pubspecIssues);
  }

  final lockfileDirectory = TenantProject.resolveLockfileDirectory(
    projectDirectory,
    isWorkspaceResolved: pubspecValidator.isWorkspaceResolved(),
  );

  final config = ScloudConfigIO.readFromFile(projectConfigFilePath);

  await _runDartPubGetIfNeeded(logger, skipDartPubGet, lockfileDirectory);

  final lockfile = File(p.join(lockfileDirectory.path, 'pubspec.lock'));

  final lockfileDartSdk = TenantProjectPubspec.readLockfileDartSdk(lockfile);
  if (lockfileDartSdk.issues.isNotEmpty) {
    throw FailureException(errors: lockfileDartSdk.issues);
  }

  final workspaceRootDir = pubspecValidator.isWorkspaceResolved()
      ? lockfileDirectory
      : null;

  final dartVersion = DartSdkSelector.selectDartSdkVersion(
    supportedSdkMinorVersions: supportedSdkVersions,
    commandLineVersion: dartVersionOverride,
    scloudVersion: config?.dartSdk,
    toolVersionsVersion: ToolVersionsIO.readDartVersionFromToolVersions(
      <Directory>[projectDirectory, ?workspaceRootDir],
    ),
    pubspecVersionConstraint: pubspecValidator.environmentSdkConstraint(),
    lockVersionConstraint: lockfileDartSdk.constraint,
  );
  logger.debug('Selected Dart SDK $dartVersion.');

  if (config != null && config.scripts.preDeploy.isNotEmpty) {
    await ScriptRunner.runScripts(
      config.scripts.preDeploy,
      projectDir,
      logger,
      scriptType: 'pre-deploy',
      padHeadingRight: StatusCommands.progressMessagePadLength,
      stdout: stdout,
      stderr: stderr,
    );
  }

  await warnIfLegacyServerpodWithMultipleInstances(
    cloudApiClient: cloudApiClient,
    projectId: projectId,
    logger: logger,
    serverpodVersionConstraint: pubspecValidator.serverpodVersion,
  );

  final gitMetadata = await readGitMetadata(projectDir, logger: logger);
  if (gitMetadata != null && gitMetadata.hasUncommittedChanges) {
    logger.warning(
      'You have uncommitted changes in your git repository.',
      hint:
          'These changes are included in the deployment, but the deploy '
          'is recorded against the last commit. Commit your changes for '
          'an accurate deployment history.',
      newParagraph: true,
    );
  }

  final projectFilePreparer = TenantProject.prepare(
    projectDirectory,
    tenantProjectPubspec: pubspecValidator,
  );

  if (projectFilePreparer.isWorkspace) {
    logger.list(
      projectFilePreparer.includedPackagePaths,
      title: 'Including workspace packages',
      level: LogLevel.debug,
      newParagraph: true,
    );
  }

  final projectZip = await DeployArchive.zip(
    logger: logger,
    projectFilePreparer: projectFilePreparer,
    concurrency: concurrency,
    showFiles: showFiles,
  );

  if (outputPath != null) {
    await DeployArchive.writeZipFile(
      logger: logger,
      outputPath: outputPath,
      projectZip: projectZip,
    );
  }

  if (wetRun) {
    await logger.progress(
      'Wet run, skipping deployment',
      successMessage: 'Wet run, skipping deployment.',
      padRight: StatusCommands.progressMessagePadLength,
      () async {
        return true;
      },
    );

    if (config != null && config.scripts.postDeploy.isNotEmpty) {
      await ScriptRunner.runScripts(
        config.scripts.postDeploy,
        projectDir,
        logger,
        scriptType: 'post-deploy',
        padHeadingRight: StatusCommands.progressMessagePadLength,
        stdout: stdout,
        stderr: stderr,
      );
    }

    logger.info(
      'The project was not deployed. '
      'Run the command again without --wet-run to deploy it.',
      newParagraph: true,
    );
    return;
  }

  final uploadDescription = await _createUploadDescription(
    logger,
    cloudApiClient,
    projectId,
    pubspecValidator.serverpodVersion,
    '$dartVersion.0',
    gitMetadata,
    archiveSize: projectZip.length,
    baseCommand: baseCommand,
  );

  await DeployArchive.upload(
    logger: logger,
    fileUploaderFactory: fileUploaderFactory,
    uploadDescription: uploadDescription,
    projectZip: projectZip,
  );

  if (config != null && config.scripts.postDeploy.isNotEmpty) {
    await ScriptRunner.runScripts(
      config.scripts.postDeploy,
      projectDir,
      logger,
      scriptType: 'post-deploy',
      padHeadingRight: StatusCommands.progressMessagePadLength,
      stdout: stdout,
      stderr: stderr,
    );
  }

  if (skipTailingStatus) {
    logger.terminalCommand(
      '$baseCommand status deployment show',
      message: 'To view the deployment status, run this command:',
      newParagraph: true,
    );
    return;
  }

  final attemptId = resolveUploadIdFromUploadDescription(uploadDescription);
  if (attemptId == null) {
    throw FailureException(
      error: 'Failed to get deployment status.',
      hint:
          'Run this command to see recent deployments: '
          '$baseCommand status deployment list',
    );
  }

  await StatusCommands.tailDeploymentStatus(
    cloudApiClient,
    logger: logger,
    baseCommand: baseCommand,
    cloudCapsuleId: projectId,
    attemptId: attemptId,
    skipUploadStage: true,
  );
}