ConfigPushCommand.php

<?php

declare(strict_types=1);

namespace Acquia\Cli\Command\Source;

use Acquia\Cli\ApiCredentialsInterface;
use Acquia\Cli\Attribute\RequireAuth;
use Acquia\Cli\CloudApi\ClientService;
use Acquia\Cli\Command\CommandBase;
use Acquia\Cli\DataStore\AcquiaCliDatastore;
use Acquia\Cli\DataStore\CloudDataStore;
use Acquia\Cli\Exception\AcquiaCliException;
use Acquia\Cli\Helpers\LocalMachineHelper;
use Acquia\Cli\Helpers\LoopHelper;
use Acquia\Cli\Helpers\SshHelper;
use Acquia\Cli\Helpers\TelemetryHelper;
use Acquia\Cli\SasApi\SasClientService;
use Acquia\Cli\SasApi\SourceConfig;
use Psr\Log\LoggerInterface;
use SelfUpdate\SelfUpdateManager;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Yaml\Yaml;

/**
 * Push local Source configuration to a site via the Sites Aggregation Service.
 *
 * Reads every .yml file under .acquia/config/ in the current project and
 * assembles them into a single YAML document keyed by config collection (the
 * root directory is the default collection) and then by config name. This
 * mirrors the structure produced by `drush source:config:dump --single-yaml`,
 * which is what a future source:config:pull command writes out.
 */
#[RequireAuth]
#[AsCommand(name: 'source:config:push', description: 'Push Source configuration from .acquia/config to a site')]
final class ConfigPushCommand extends CommandBase
{
    /**
     * The directory (relative to the project root) holding config files.
     */
    private const CONFIG_DIR = '.acquia/config';

    public function __construct(
        LocalMachineHelper $localMachineHelper,
        CloudDataStore $datastoreCloud,
        AcquiaCliDatastore $datastoreAcli,
        ApiCredentialsInterface $cloudCredentials,
        TelemetryHelper $telemetryHelper,
        string $projectDir,
        ClientService $cloudApiClientService,
        SshHelper $sshHelper,
        string $sshDir,
        LoggerInterface $logger,
        SelfUpdateManager $selfUpdateManager,
        private readonly SasClientService $sasClient,
    ) {
        parent::__construct(
            $localMachineHelper,
            $datastoreCloud,
            $datastoreAcli,
            $cloudCredentials,
            $telemetryHelper,
            $projectDir,
            $cloudApiClientService,
            $sshHelper,
            $sshDir,
            $logger,
            $selfUpdateManager,
        );
    }

    protected function configure(): void
    {
        $this
            ->acceptEnvironmentId()
            ->acceptSiteInstanceId()
            ->addOption('force', 'f', InputOption::VALUE_NONE, 'Do not ask for confirmation before pushing');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $this->setDirAndRequireProjectCwd($input);

        $siteInstance = $this->determineSiteInstance($input);
        if ($siteInstance === null) {
            throw new AcquiaCliException(
                'Could not determine a Source site instance. Run this command from a repository linked to an Acquia Cloud application, or pass --siteInstanceId.'
            );
        }

        $environment = $siteInstance->environment;

        $payload = $this->assemblePayload();
        if ($payload === []) {
            throw new AcquiaCliException(sprintf('No configuration files found in %s.', self::CONFIG_DIR));
        }
        $yaml = Yaml::dump($payload, 10, 2);

        if (!$input->getOption('force')) {
            $answer = $this->io->confirm(
                sprintf('Push configuration from %s to the %s environment?', self::CONFIG_DIR, $environment->name),
                false,
            );
            if (!$answer) {
                return Command::SUCCESS;
            }
        }

        $sourceConfig = new SourceConfig($this->sasClient->getClient());

        $response = $sourceConfig->push($environment->uuid, $yaml);
        // @todo DXBE-20: Confirm the operation ID field name with the SAS team.
        $operationId = $response->id ?? null;
        if (!is_string($operationId)) {
            throw new AcquiaCliException('The SAS API response did not include an operation ID.');
        }

        $this->io->writeln(sprintf('Config push submitted (operation %s). Waiting for it to complete...', $operationId));

        return $this->waitForPush($sourceConfig, $operationId) ? Command::SUCCESS : Command::FAILURE;
    }

    /**
     * Assemble the payload from the config files on disk.
     *
     * Returns a structure keyed by collection name (the default collection is
     * the empty string; subdirectories become dotted collection names like
     * "language.es"), then by config name (the file name minus .yml).
     * Collections with no config files are omitted.
     *
     * @return array<string, array<string, mixed>>
     */
    private function assemblePayload(): array
    {
        $configDir = $this->dir . '/' . self::CONFIG_DIR;
        if (!is_dir($configDir)) {
            return [];
        }

        $finder = new Finder();
        $finder->files()->in($configDir)->name('*.yml');

        $payload = [];
        foreach ($finder as $file) {
            $relativeDir = $file->getRelativePath();
            // The root directory maps to the default collection ("").
            // Subdirectories map to dotted collection names: language/es
            // becomes language.es.
            $collection = $relativeDir === '' ? '' : str_replace('/', '.', $relativeDir);
            $name = $file->getBasename('.yml');
            $payload[$collection][$name] = Yaml::parseFile($file->getPathname());
        }

        return $payload;
    }

    /**
     * Poll the operation until it leaves the in-progress states.
     *
     * @todo DXBE-20: Confirm the status field name and its values with the
     *   SAS team. Assumes a `status` field mirroring the task gateway's
     *   phases (pending/running/succeeded/failed).
     */
    private function waitForPush(SourceConfig $sourceConfig, string $operationId): bool
    {
        $status = null;
        $checkStatus = static function () use ($sourceConfig, $operationId, &$status): bool {
            $response = $sourceConfig->getPushStatus($operationId);
            $status = $response->status ?? 'unknown';
            return !in_array($status, ['pending', 'running'], true);
        };
        $onDone = static function (): void {
        };

        LoopHelper::getLoopy($this->output, $this->io, 'Pushing configuration...', $checkStatus, $onDone);

        if ($status === 'succeeded') {
            $this->io->success('Configuration pushed successfully.');
            return true;
        }

        $this->io->error(sprintf('Config push ended with status: %s', $status));
        return false;
    }
}