class Migration in Drupal 9

Same name and namespace in other branches

8 core/modules/migrate/src/Plugin/Migration.php \Drupal\migrate\Plugin\Migration
10 core/modules/migrate/src/Plugin/Migration.php \Drupal\migrate\Plugin\Migration

Defines the Migration plugin.

The migration plugin represents one single migration and acts like a container for the information about a single migration such as the source, process and destination plugins.

Hierarchy

class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
- class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
  - class \Drupal\migrate\Plugin\Migration implements ContainerFactoryPluginInterface, MigrationInterface, RequirementsInterface

Expanded class hierarchy of Migration

7 files declare their use of Migration

D6NodeTranslation.php in core/modules/node/src/Plugin/migrate/D6NodeTranslation.php
D7NodeTranslation.php in core/modules/node/src/Plugin/migrate/D7NodeTranslation.php
FieldMigration.php in core/modules/migrate_drupal/src/Plugin/migrate/FieldMigration.php
FilterFormatPermissionTest.php in core/modules/filter/tests/src/Kernel/Migrate/d6/FilterFormatPermissionTest.php
MigrationPluginManagerTest.php in core/modules/migrate/tests/src/Unit/MigrationPluginManagerTest.php

... See full list

3 string references to 'Migration'

migrate.info.yml in core/modules/migrate/migrate.info.yml: core/modules/migrate/migrate.info.yml
migrate_drupal.info.yml in core/modules/migrate_drupal/migrate_drupal.info.yml: core/modules/migrate_drupal/migrate_drupal.info.yml
migrate_drupal_ui.info.yml in core/modules/migrate_drupal_ui/migrate_drupal_ui.info.yml: core/modules/migrate_drupal_ui/migrate_drupal_ui.info.yml

File

core/modules/migrate/src/Plugin/Migration.php, line 21

Namespace

Drupal\migrate\Plugin

View source

class Migration extends PluginBase implements MigrationInterface, RequirementsInterface, ContainerFactoryPluginInterface {

  /**
   * The migration ID (machine name).
   *
   * @var string
   */
  protected $id;

  /**
   * The human-readable label for the migration.
   *
   * @var string
   */
  protected $label;

  /**
   * The plugin ID for the row.
   *
   * @var string
   */
  protected $row;

  /**
   * The source configuration, with at least a 'plugin' key.
   *
   * Used to initialize the $sourcePlugin.
   *
   * @var array
   */
  protected $source;

  /**
   * The source plugin.
   *
   * @var \Drupal\migrate\Plugin\MigrateSourceInterface
   */
  protected $sourcePlugin;

  /**
   * The configuration describing the process plugins.
   *
   * This is a strictly internal property and should not returned to calling
   * code, use getProcess() instead.
   *
   * @var array
   */
  protected $process = [];

  /**
   * The cached process plugins.
   *
   * @var array
   */
  protected $processPlugins = [];

  /**
   * The destination configuration, with at least a 'plugin' key.
   *
   * Used to initialize $destinationPlugin.
   *
   * @var array
   */
  protected $destination;

  /**
   * The destination plugin.
   *
   * @var \Drupal\migrate\Plugin\MigrateDestinationInterface
   */
  protected $destinationPlugin;

  /**
   * The identifier map data.
   *
   * Used to initialize $idMapPlugin.
   *
   * @var string
   */
  protected $idMap = [];

  /**
   * The identifier map.
   *
   * @var \Drupal\migrate\Plugin\MigrateIdMapInterface
   */
  protected $idMapPlugin;

  /**
   * The source identifiers.
   *
   * An array of source identifiers: the keys are the name of the properties,
   * the values are dependent on the ID map plugin.
   *
   * @var array
   */
  protected $sourceIds = [];

  /**
   * The destination identifiers.
   *
   * An array of destination identifiers: the keys are the name of the
   * properties, the values are dependent on the ID map plugin.
   *
   * @var array
   */
  protected $destinationIds = [];

  /**
   * Specify value of source_row_status for current map row. Usually set by
   * MigrateFieldHandler implementations.
   *
   * @var int
   */
  protected $sourceRowStatus = MigrateIdMapInterface::STATUS_IMPORTED;

  /**
   * Track time of last import if TRUE.
   *
   * @var bool
   */
  protected $trackLastImported = FALSE;

  /**
   * These migrations must be already executed before this migration can run.
   *
   * @var array
   */
  protected $requirements = [];

  /**
   * An optional list of tags, used by the plugin manager for filtering.
   *
   * @var array
   */
  protected $migration_tags = [];

  /**
   * Whether the migration is auditable.
   *
   * If set to TRUE, the migration's IDs will be audited. This means that, if
   * the highest destination ID is greater than the highest source ID, a warning
   * will be displayed that entities might be overwritten.
   *
   * @var bool
   */
  protected $audit = FALSE;

  /**
   * These migrations, if run, must be executed before this migration.
   *
   * These are different from the configuration dependencies. Migration
   * dependencies are only used to store relationships between migrations.
   *
   * The migration_dependencies value is structured like this:
   * @code
   * array(
   *   'required' => array(
   *     // An array of migration IDs that must be run before this migration.
   *   ),
   *   'optional' => array(
   *     // An array of migration IDs that, if they exist, must be run before
   *     // this migration.
   *   ),
   * );
   * @endcode
   *
   * @var array
   */
  protected $migration_dependencies = [];

  /**
   * The migration's configuration dependencies.
   *
   * These store any dependencies on modules or other configuration (including
   * other migrations) that must be available before the migration can be
   * created.
   *
   * @see \Drupal\Core\Config\Entity\ConfigDependencyManager
   *
   * @var array
   */
  protected $dependencies = [];

  /**
   * The migration plugin manager for loading other migration plugins.
   *
   * @var \Drupal\migrate\Plugin\MigrationPluginManagerInterface
   */
  protected $migrationPluginManager;

  /**
   * The source plugin manager.
   *
   * @var \Drupal\migrate\Plugin\MigratePluginManager
   */
  protected $sourcePluginManager;

  /**
   * The process plugin manager.
   *
   * @var \Drupal\migrate\Plugin\MigratePluginManager
   */
  protected $processPluginManager;

  /**
   * The destination plugin manager.
   *
   * @var \Drupal\migrate\Plugin\MigrateDestinationPluginManager
   */
  protected $destinationPluginManager;

  /**
   * The ID map plugin manager.
   *
   * @var \Drupal\migrate\Plugin\MigratePluginManager
   */
  protected $idMapPluginManager;

  /**
   * Labels corresponding to each defined status.
   *
   * @var array
   */
  protected $statusLabels = [
    self::STATUS_IDLE => 'Idle',
    self::STATUS_IMPORTING => 'Importing',
    self::STATUS_ROLLING_BACK => 'Rolling back',
    self::STATUS_STOPPING => 'Stopping',
    self::STATUS_DISABLED => 'Disabled',
  ];

  /**
   * Constructs a Migration.
   *
   * @param array $configuration
   *   Plugin configuration.
   * @param string $plugin_id
   *   The plugin ID.
   * @param mixed $plugin_definition
   *   The plugin definition.
   * @param \Drupal\migrate\Plugin\MigrationPluginManagerInterface $migration_plugin_manager
   *   The migration plugin manager.
   * @param \Drupal\migrate\Plugin\MigratePluginManagerInterface $source_plugin_manager
   *   The source migration plugin manager.
   * @param \Drupal\migrate\Plugin\MigratePluginManagerInterface $process_plugin_manager
   *   The process migration plugin manager.
   * @param \Drupal\migrate\Plugin\MigrateDestinationPluginManager $destination_plugin_manager
   *   The destination migration plugin manager.
   * @param \Drupal\migrate\Plugin\MigratePluginManagerInterface $idmap_plugin_manager
   *   The ID map migration plugin manager.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationPluginManagerInterface $migration_plugin_manager, MigratePluginManagerInterface $source_plugin_manager, MigratePluginManagerInterface $process_plugin_manager, MigrateDestinationPluginManager $destination_plugin_manager, MigratePluginManagerInterface $idmap_plugin_manager) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->migrationPluginManager = $migration_plugin_manager;
    $this->sourcePluginManager = $source_plugin_manager;
    $this->processPluginManager = $process_plugin_manager;
    $this->destinationPluginManager = $destination_plugin_manager;
    $this->idMapPluginManager = $idmap_plugin_manager;
    foreach (NestedArray::mergeDeepArray([
      $plugin_definition,
      $configuration,
    ], TRUE) as $key => $value) {
      $this->{$key} = $value;
    }
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('plugin.manager.migration'), $container
      ->get('plugin.manager.migrate.source'), $container
      ->get('plugin.manager.migrate.process'), $container
      ->get('plugin.manager.migrate.destination'), $container
      ->get('plugin.manager.migrate.id_map'));
  }

  /**
   * {@inheritdoc}
   */
  public function id() {
    return $this->pluginId;
  }

  /**
   * {@inheritdoc}
   */
  public function label() {
    return $this->label;
  }

  /**
   * Retrieves the ID map plugin.
   *
   * @return \Drupal\migrate\Plugin\MigrateIdMapInterface
   *   The ID map plugin.
   */
  public function getIdMapPlugin() {
    return $this->idMapPlugin;
  }

  /**
   * {@inheritdoc}
   */
  public function getSourcePlugin() {
    if (!isset($this->sourcePlugin)) {
      $this->sourcePlugin = $this->sourcePluginManager
        ->createInstance($this->source['plugin'], $this->source, $this);
    }
    return $this->sourcePlugin;
  }

  /**
   * {@inheritdoc}
   */
  public function getProcessPlugins(array $process = NULL) {
    if (!isset($process)) {
      $process = $this
        ->getProcess();
    }
    $index = serialize($process);
    if (!isset($this->processPlugins[$index])) {
      $this->processPlugins[$index] = [];
      foreach ($this
        ->getProcessNormalized($process) as $property => $configurations) {
        $this->processPlugins[$index][$property] = [];
        foreach ($configurations as $configuration) {
          if (isset($configuration['source'])) {
            $this->processPlugins[$index][$property][] = $this->processPluginManager
              ->createInstance('get', $configuration, $this);
          }

          // Get is already handled.
          if ($configuration['plugin'] != 'get') {
            $this->processPlugins[$index][$property][] = $this->processPluginManager
              ->createInstance($configuration['plugin'], $configuration, $this);
          }
          if (!$this->processPlugins[$index][$property]) {
            throw new MigrateException("Invalid process configuration for {$property}");
          }
        }
      }
    }
    return $this->processPlugins[$index];
  }

  /**
   * Resolve shorthands into a list of plugin configurations.
   *
   * @param array $process
   *   A process configuration array.
   *
   * @return array
   *   The normalized process configuration.
   */
  protected function getProcessNormalized(array $process) {
    $normalized_configurations = [];
    foreach ($process as $destination => $configuration) {
      if (is_string($configuration)) {
        $configuration = [
          'plugin' => 'get',
          'source' => $configuration,
        ];
      }
      if (isset($configuration['plugin'])) {
        $configuration = [
          $configuration,
        ];
      }
      if (!is_array($configuration)) {
        $migration_id = $this
          ->getPluginId();
        throw new MigrateException("Invalid process for destination '{$destination}' in migration '{$migration_id}'");
      }
      $normalized_configurations[$destination] = $configuration;
    }
    return $normalized_configurations;
  }

  /**
   * {@inheritdoc}
   */
  public function getDestinationPlugin($stub_being_requested = FALSE) {
    if ($stub_being_requested && !empty($this->destination['no_stub'])) {
      throw new MigrateSkipRowException('Stub requested but not made because no_stub configuration is set.');
    }
    if (!isset($this->destinationPlugin)) {
      $this->destinationPlugin = $this->destinationPluginManager
        ->createInstance($this->destination['plugin'], $this->destination, $this);
    }
    return $this->destinationPlugin;
  }

  /**
   * {@inheritdoc}
   */
  public function getIdMap() {
    if (!isset($this->idMapPlugin)) {
      $configuration = $this->idMap;
      $plugin = isset($configuration['plugin']) ? $configuration['plugin'] : 'sql';
      $this->idMapPlugin = $this->idMapPluginManager
        ->createInstance($plugin, $configuration, $this);
    }
    return $this->idMapPlugin;
  }

  /**
   * {@inheritDoc}
   */
  public function getRequirements() : array {
    return $this->requirements;
  }

  /**
   * {@inheritdoc}
   */
  public function checkRequirements() {

    // Check whether the current migration source and destination plugin
    // requirements are met or not.
    if ($this
      ->getSourcePlugin() instanceof RequirementsInterface) {
      $this
        ->getSourcePlugin()
        ->checkRequirements();
    }
    if ($this
      ->getDestinationPlugin() instanceof RequirementsInterface) {
      $this
        ->getDestinationPlugin()
        ->checkRequirements();
    }
    if (empty($this->requirements)) {

      // There are no requirements to check.
      return;
    }

    /** @var \Drupal\migrate\Plugin\MigrationInterface[] $required_migrations */
    $required_migrations = $this
      ->getMigrationPluginManager()
      ->createInstances($this->requirements);
    $missing_migrations = array_diff($this->requirements, array_keys($required_migrations));

    // Check if the dependencies are in good shape.
    foreach ($required_migrations as $migration_id => $required_migration) {
      if (!$required_migration
        ->allRowsProcessed()) {
        $missing_migrations[] = $migration_id;
      }
    }
    if ($missing_migrations) {
      throw new RequirementsException('Missing migrations ' . implode(', ', $missing_migrations) . '.', [
        'requirements' => $missing_migrations,
      ]);
    }
  }

  /**
   * Gets the migration plugin manager.
   *
   * @return \Drupal\migrate\Plugin\MigrationPluginManagerInterface
   *   The migration plugin manager.
   */
  protected function getMigrationPluginManager() {
    return $this->migrationPluginManager;
  }

  /**
   * {@inheritdoc}
   */
  public function setStatus($status) {
    \Drupal::keyValue('migrate_status')
      ->set($this
      ->id(), $status);
  }

  /**
   * {@inheritdoc}
   */
  public function getStatus() {
    return \Drupal::keyValue('migrate_status')
      ->get($this
      ->id(), static::STATUS_IDLE);
  }

  /**
   * {@inheritdoc}
   */
  public function getStatusLabel() {
    $status = $this
      ->getStatus();
    if (isset($this->statusLabels[$status])) {
      return $this->statusLabels[$status];
    }
    else {
      return '';
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getInterruptionResult() {
    return \Drupal::keyValue('migrate_interruption_result')
      ->get($this
      ->id(), static::RESULT_INCOMPLETE);
  }

  /**
   * {@inheritdoc}
   */
  public function clearInterruptionResult() {
    \Drupal::keyValue('migrate_interruption_result')
      ->delete($this
      ->id());
  }

  /**
   * {@inheritdoc}
   */
  public function interruptMigration($result) {
    $this
      ->setStatus(MigrationInterface::STATUS_STOPPING);
    \Drupal::keyValue('migrate_interruption_result')
      ->set($this
      ->id(), $result);
  }

  /**
   * {@inheritdoc}
   */
  public function allRowsProcessed() {
    $source_count = $this
      ->getSourcePlugin()
      ->count();

    // If the source is uncountable, we have no way of knowing if it's
    // complete, so stipulate that it is.
    if ($source_count < 0) {
      return TRUE;
    }
    $processed_count = $this
      ->getIdMap()
      ->processedCount();

    // We don't use == because in some circumstances (like unresolved stubs
    // being created), the processed count may be higher than the available
    // source rows.
    return $source_count <= $processed_count;
  }

  /**
   * {@inheritdoc}
   */
  public function set($property_name, $value) {
    if ($property_name == 'source') {

      // Invalidate the source plugin.
      unset($this->sourcePlugin);
    }
    elseif ($property_name === 'destination') {

      // Invalidate the destination plugin.
      unset($this->destinationPlugin);
    }
    $this->{$property_name} = $value;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function getProcess() {
    return $this
      ->getProcessNormalized($this->process);
  }

  /**
   * {@inheritdoc}
   */
  public function setProcess(array $process) {
    $this->process = $process;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function setProcessOfProperty($property, $process_of_property) {
    $this->process[$property] = $process_of_property;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function mergeProcessOfProperty($property, array $process_of_property) {

    // If we already have a process value then merge the incoming process array
    // otherwise simply set it.
    $current_process = $this
      ->getProcess();
    if (isset($current_process[$property])) {
      $this->process = NestedArray::mergeDeepArray([
        $current_process,
        $this
          ->getProcessNormalized([
          $property => $process_of_property,
        ]),
      ], TRUE);
    }
    else {
      $this
        ->setProcessOfProperty($property, $process_of_property);
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function isTrackLastImported() {
    return $this->trackLastImported;
  }

  /**
   * {@inheritdoc}
   */
  public function setTrackLastImported($track_last_imported) {
    $this->trackLastImported = (bool) $track_last_imported;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function getMigrationDependencies() {
    $this->migration_dependencies = ($this->migration_dependencies ?: []) + [
      'required' => [],
      'optional' => [],
    ];
    if (count($this->migration_dependencies) !== 2 || !is_array($this->migration_dependencies['required']) || !is_array($this->migration_dependencies['optional'])) {
      throw new InvalidPluginDefinitionException($this
        ->id(), "Invalid migration dependencies configuration for migration {$this->id()}");
    }
    $this->migration_dependencies['optional'] = array_unique(array_merge($this->migration_dependencies['optional'], $this
      ->findMigrationDependencies($this->process)));
    return $this->migration_dependencies;
  }

  /**
   * Find migration dependencies from migration_lookup and sub_process plugins.
   *
   * @param array $process
   *   A process configuration array.
   *
   * @return array
   *   The migration dependencies.
   */
  protected function findMigrationDependencies($process) {
    $return = [];
    foreach ($this
      ->getProcessNormalized($process) as $process_pipeline) {
      foreach ($process_pipeline as $plugin_configuration) {

        // If the migration uses a deriver and has a migration_lookup with
        // itself as the source migration, then skip adding dependencies.
        // Otherwise the migration will depend on all the variations of itself.
        // See d7_taxonomy_term for an example.
        if (isset($this->deriver) && $plugin_configuration['plugin'] === 'migration_lookup' && $plugin_configuration['migration'] == $this
          ->getBaseId()) {
          continue;
        }
        if (in_array($plugin_configuration['plugin'], [
          'migration',
          'migration_lookup',
        ], TRUE)) {
          $return = array_merge($return, (array) $plugin_configuration['migration']);
        }
        if (in_array($plugin_configuration['plugin'], [
          'iterator',
          'sub_process',
        ], TRUE)) {
          $return = array_merge($return, $this
            ->findMigrationDependencies($plugin_configuration['process']));
        }
      }
    }
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function getPluginDefinition() {
    $definition = [];

    // While normal plugins do not change their definitions on the fly, this
    // one does so accommodate for that.
    foreach (parent::getPluginDefinition() as $key => $value) {
      $definition[$key] = isset($this->{$key}) ? $this->{$key} : $value;
    }
    return $definition;
  }

  /**
   * {@inheritdoc}
   */
  public function getDestinationConfiguration() {
    return $this->destination;
  }

  /**
   * {@inheritdoc}
   */
  public function getSourceConfiguration() {
    return $this->source;
  }

  /**
   * {@inheritdoc}
   */
  public function getTrackLastImported() {
    return $this->trackLastImported;
  }

  /**
   * {@inheritdoc}
   */
  public function getDestinationIds() {
    return $this->destinationIds;
  }

  /**
   * {@inheritdoc}
   */
  public function getMigrationTags() {
    return $this->migration_tags;
  }

  /**
   * {@inheritdoc}
   */
  public function isAuditable() {
    return (bool) $this->audit;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
DependencySerializationTrait::$_entityStorages	protected	property
DependencySerializationTrait::$_serviceIds	protected	property
DependencySerializationTrait::__sleep	public	function		2
DependencySerializationTrait::__wakeup	public	function		2
MessengerTrait::$messenger	protected	property	The messenger.	27
MessengerTrait::messenger	public	function	Gets the messenger.	27
MessengerTrait::setMessenger	public	function	Sets the messenger.
Migration::$audit	protected	property	Whether the migration is auditable.
Migration::$dependencies	protected	property	The migration's configuration dependencies.
Migration::$destination	protected	property	The destination configuration, with at least a 'plugin' key.
Migration::$destinationIds	protected	property	The destination identifiers.
Migration::$destinationPlugin	protected	property	The destination plugin.
Migration::$destinationPluginManager	protected	property	The destination plugin manager.
Migration::$id	protected	property	The migration ID (machine name).	1
Migration::$idMap	protected	property	The identifier map data.
Migration::$idMapPlugin	protected	property	The identifier map.
Migration::$idMapPluginManager	protected	property	The ID map plugin manager.
Migration::$label	protected	property	The human-readable label for the migration.
Migration::$migrationPluginManager	protected	property	The migration plugin manager for loading other migration plugins.
Migration::$migration_dependencies	protected	property	These migrations, if run, must be executed before this migration.
Migration::$migration_tags	protected	property	An optional list of tags, used by the plugin manager for filtering.
Migration::$process	protected	property	The configuration describing the process plugins.
Migration::$processPluginManager	protected	property	The process plugin manager.
Migration::$processPlugins	protected	property	The cached process plugins.
Migration::$requirements	protected	property	These migrations must be already executed before this migration can run.
Migration::$row	protected	property	The plugin ID for the row.
Migration::$source	protected	property	The source configuration, with at least a 'plugin' key.
Migration::$sourceIds	protected	property	The source identifiers.
Migration::$sourcePlugin	protected	property	The source plugin.
Migration::$sourcePluginManager	protected	property	The source plugin manager.
Migration::$sourceRowStatus	protected	property	Specify value of source_row_status for current map row. Usually set by MigrateFieldHandler implementations.
Migration::$statusLabels	protected	property	Labels corresponding to each defined status.
Migration::$trackLastImported	protected	property	Track time of last import if TRUE.
Migration::allRowsProcessed	public	function	Check if all source rows from this migration have been processed. Overrides MigrationInterface::allRowsProcessed
Migration::checkRequirements	public	function	Checks if requirements for this plugin are OK. Overrides RequirementsInterface::checkRequirements
Migration::clearInterruptionResult	public	function	Clears the result to return upon interruption. Overrides MigrationInterface::clearInterruptionResult
Migration::create	public static	function	Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create	1
Migration::findMigrationDependencies	protected	function	Find migration dependencies from migration_lookup and sub_process plugins.
Migration::getDestinationConfiguration	public	function	Get the destination configuration, with at least a 'plugin' key. Overrides MigrationInterface::getDestinationConfiguration
Migration::getDestinationIds	public	function	The destination identifiers. Overrides MigrationInterface::getDestinationIds
Migration::getDestinationPlugin	public	function	Returns the initialized destination plugin. Overrides MigrationInterface::getDestinationPlugin
Migration::getIdMap	public	function	Returns the initialized id_map plugin. Overrides MigrationInterface::getIdMap
Migration::getIdMapPlugin	public	function	Retrieves the ID map plugin.
Migration::getInterruptionResult	public	function	Get the result to return upon interruption. Overrides MigrationInterface::getInterruptionResult
Migration::getMigrationDependencies	public	function	Get the dependencies for this migration. Overrides MigrationInterface::getMigrationDependencies	1
Migration::getMigrationPluginManager	protected	function	Gets the migration plugin manager.
Migration::getMigrationTags	public	function	The migration tags. Overrides MigrationInterface::getMigrationTags
Migration::getPluginDefinition	public	function	Gets the definition of the plugin implementation. Overrides PluginBase::getPluginDefinition
Migration::getProcess	public	function	Get the normalized process pipeline configuration describing the process plugins. Overrides MigrationInterface::getProcess	2
Migration::getProcessNormalized	protected	function	Resolve shorthands into a list of plugin configurations.
Migration::getProcessPlugins	public	function	Returns the process plugins. Overrides MigrationInterface::getProcessPlugins
Migration::getRequirements	public	function	Get a list of required plugin IDs. Overrides MigrationInterface::getRequirements
Migration::getSourceConfiguration	public	function	Get the source configuration, with at least a 'plugin' key. Overrides MigrationInterface::getSourceConfiguration
Migration::getSourcePlugin	public	function	Returns the initialized source plugin. Overrides MigrationInterface::getSourcePlugin
Migration::getStatus	public	function	Get the current migration status. Overrides MigrationInterface::getStatus
Migration::getStatusLabel	public	function	Retrieve a label for the current status. Overrides MigrationInterface::getStatusLabel
Migration::getTrackLastImported	public	function	If true, track time of last import. Overrides MigrationInterface::getTrackLastImported
Migration::id	public	function	An alias for getPluginId() for backwards compatibility reasons. Overrides MigrationInterface::id	1
Migration::interruptMigration	public	function	Signal that the migration should be interrupted with the specified result code. Overrides MigrationInterface::interruptMigration
Migration::isAuditable	public	function	Indicates if the migration is auditable. Overrides MigrationInterface::isAuditable
Migration::isTrackLastImported	public	function	Checks if the migration should track time of last import. Overrides MigrationInterface::isTrackLastImported
Migration::label	public	function	Get the plugin label. Overrides MigrationInterface::label
Migration::mergeProcessOfProperty	public	function	Merge the process pipeline configuration for a single property. Overrides MigrationInterface::mergeProcessOfProperty
Migration::set	public	function		1
Migration::setProcess	public	function	Allows you to override the entire process configuration. Overrides MigrationInterface::setProcess
Migration::setProcessOfProperty	public	function	Set the process pipeline configuration for an individual destination field. Overrides MigrationInterface::setProcessOfProperty
Migration::setStatus	public	function	Set the current migration status. Overrides MigrationInterface::setStatus
Migration::setTrackLastImported	public	function	Set if the migration should track time of last import. Overrides MigrationInterface::setTrackLastImported
Migration::__construct	public	function	Constructs a Migration. Overrides PluginBase::__construct	3
MigrationInterface::MESSAGE_ERROR		constant	Migration error.
MigrationInterface::MESSAGE_INFORMATIONAL		constant	Migration info.
MigrationInterface::MESSAGE_NOTICE		constant	Migration notice.
MigrationInterface::MESSAGE_WARNING		constant	Migration warning.
MigrationInterface::RESULT_COMPLETED		constant	All records have been processed.
MigrationInterface::RESULT_DISABLED		constant	This migration is disabled, skipping.
MigrationInterface::RESULT_FAILED		constant	The process had a fatal error.
MigrationInterface::RESULT_INCOMPLETE		constant	The process has stopped itself (e.g., the memory limit is approaching).
MigrationInterface::RESULT_SKIPPED		constant	Dependencies are unfulfilled - skip the process.
MigrationInterface::RESULT_STOPPED		constant	The process was stopped externally (e.g., via drush migrate-stop).
MigrationInterface::STATUS_DISABLED		constant	The migration has been disabled.
MigrationInterface::STATUS_IDLE		constant	The migration is currently not running.
MigrationInterface::STATUS_IMPORTING		constant	The migration is currently importing.
MigrationInterface::STATUS_ROLLING_BACK		constant	The migration is currently being rolled back.
MigrationInterface::STATUS_STOPPING		constant	The migration is being stopped.
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId	public	function	Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId	public	function	Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	4
StringTranslationTrait::formatPlural	protected	function	Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals	protected	function	Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation	protected	function	Gets the string translation service.
StringTranslationTrait::setStringTranslation	public	function	Sets the string translation service to use.	2
StringTranslationTrait::t	protected	function	Translates a string to the current language or to a given language.

You are here

class Migration in Drupal 9

Hierarchy

File

Namespace

Members

API Navigation