Drush.php

Go to the documentation of this file.

<?php
 
namespace Drupal\datastore;
 
use Consolidation\OutputFormatters\StructuredData\RowsOfFields;
use Consolidation\OutputFormatters\StructuredData\UnstructuredListData;
use Drupal\datastore\Service\ResourceLocalizer;
use Drupal\datastore\Service as Datastore;
use Drupal\metastore\Service as Metastore;
use Drush\Commands\DrushCommands;
 
class Drush extends DrushCommands {
  use TableTrait;
  protected $metastoreService;
 
  protected $datastoreService;
 
  private $resourceLocalizer;
 
  public function __construct(
    Metastore $metastoreService,
    Datastore $datastoreService,
    ResourceLocalizer $resourceLocalizer
  ) {
    $this->metastoreService = $metastoreService;
    $this->datastoreService = $datastoreService;
    $this->resourceLocalizer = $resourceLocalizer;
  }
 
  public function import($uuid, $deferred = FALSE) {
 
    try {
      $this->datastoreService->import($uuid, $deferred);
    }
    catch (\Exception $e) {
      $this->logger->error("We were not able to load the entity with uuid {$uuid}");
      $this->logger->debug($e->getMessage());
    }
  }
 
  public function list($options = [
    'format' => 'table',
    'status' => NULL,
    'uuid-only' => FALSE,
  ]) {
    $status = $options['status'];
    $uuid_only = $options['uuid-only'];
 
    $list = $this->datastoreService->list();
    $rows = [];
    foreach ($list as $uuid => $item) {
      $rows[] = $this->createRow($uuid, $item);
    }
 
    if (!empty($status)) {
      $rows = array_filter($rows, function ($row) use ($status) {
        if ($row['fileFetcherStatus'] == $status || $row['importerStatus'] == $status) {
          return TRUE;
        }
        return FALSE;
      });
    }
 
    if ($uuid_only) {
      foreach ($rows as $index => $row) {
        $rows[$index] = $row['uuid'];
      }
      return new UnstructuredListData($rows);
    }
 
    return new RowsOfFields($rows);
  }
 
  private function createRow($uuid, $item) {
    return [
      'uuid' => $uuid,
      'fileName' => $item->fileName,
      'fileFetcherStatus' => $item->fileFetcherStatus,
      'fileFetcherBytes' => \format_size($item->fileFetcherBytes) . " ($item->fileFetcherPercentDone%)",
      'importerStatus' => $item->importerStatus,
      'importerBytes' => \format_size($item->importerBytes) . " ($item->importerPercentDone%)",
    ];
  }
 
  public function drop($uuid) {
    try {
      // Retrieve the UUID for the dataset's resource before dropping the
      // dataset's resource mapper table entry.
      $resource = $this->resourceLocalizer->get($uuid);
      if (!isset($resource)) {
        throw new \UnexpectedValueException("Resource not found with uuid {$uuid}");
      }
      $resource_uuid = $resource->getUniqueIdentifier();
      // Drop the datastore table and corresponding resource mapper table entry.
      $this->datastoreService->drop($uuid);
      $this->logger->notice("Successfully dropped the datastore for {$uuid}");
    }
    catch (\Exception $e) {
      $this->logger->error("Unable to find an entity with uuid {$uuid}");
      $this->logger->debug($e->getMessage());
      return;
    }
    catch (\TypeError $e) {
      // This will catch all TypeErrors with all arguments. Since we only
      // pass the UUID to the DataStore::Service::drop method we can safely
      // assume the issue is with the uuid.
      $this->logger->error("Unexpected entity uuid.");
      $this->logger->debug($e->getMessage());
      return;
    }
    // Drop any remaining jobstore entries for this resource.
    $this->jobstorePrune($resource_uuid);
  }
 
  public function dropAll() {
    foreach ($this->metastoreService->getAll('distribution') as $distribution) {
      $uuid = $distribution->data->{"%Ref:downloadURL"}[0]->data->identifier;
      $this->drop($uuid);
    }
  }
 
}