',
+ ],
+ 'form' => $form,
+ ];
+ }
+
+}
diff --git a/core/modules/workspace/src/Entity/Form/WorkspaceForm.php b/core/modules/workspace/src/Entity/Form/WorkspaceForm.php
new file mode 100644
index 0000000000..15819fb96e
--- /dev/null
+++ b/core/modules/workspace/src/Entity/Form/WorkspaceForm.php
@@ -0,0 +1,131 @@
+entity;
+
+ if ($this->operation == 'edit') {
+ $form['#title'] = $this->t('Edit workspace %label', ['%label' => $workspace->label()]);
+ }
+ $form['label'] = [
+ '#type' => 'textfield',
+ '#title' => $this->t('Label'),
+ '#maxlength' => 255,
+ '#default_value' => $workspace->label(),
+ '#required' => TRUE,
+ ];
+
+ $form['id'] = [
+ '#type' => 'machine_name',
+ '#title' => $this->t('Workspace ID'),
+ '#maxlength' => 255,
+ '#default_value' => $workspace->id(),
+ '#disabled' => !$workspace->isNew(),
+ '#machine_name' => [
+ 'exists' => '\Drupal\workspace\Entity\Workspace::load',
+ ],
+ '#element_validate' => [],
+ ];
+
+ $upstreams = [];
+ $upstream_manager = \Drupal::service('workspace.upstream_manager');
+ $upstream_definitions = $upstream_manager->getDefinitions();
+ foreach ($upstream_definitions as $upstream_definition) {
+ /** @var \Drupal\workspace\UpstreamInterface $instance */
+ $instance = $upstream_manager->createInstance($upstream_definition['id']);
+ $upstreams[$instance->getPluginId()] = $instance->getLabel();
+ }
+ $form['upstream'] = [
+ '#type' => 'radios',
+ '#title' => $this->t('Default upstream'),
+ '#default_value' => $workspace->get('upstream')->value,
+ '#options' => $upstreams,
+ ];
+ return parent::form($form, $form_state);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function getEditedFieldNames(FormStateInterface $form_state) {
+ return array_merge([
+ 'label',
+ 'id',
+ ], parent::getEditedFieldNames($form_state));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function flagViolations(EntityConstraintViolationListInterface $violations, array $form, FormStateInterface $form_state) {
+ // Manually flag violations of fields not handled by the form display. This
+ // is necessary as entity form displays only flag violations for fields
+ // contained in the display.
+ $field_names = [
+ 'label',
+ 'id',
+ 'upstream'
+ ];
+ foreach ($violations->getByFields($field_names) as $violation) {
+ list($field_name) = explode('.', $violation->getPropertyPath(), 2);
+ $form_state->setErrorByName($field_name, $violation->getMessage());
+ }
+ parent::flagViolations($violations, $form, $form_state);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function save(array $form, FormStateInterface $form_state) {
+ $workspace = $this->entity;
+ $status = $workspace->save();
+
+ \Drupal::service('workspace.upstream_manager')->clearCachedDefinitions();
+
+ $info = ['%info' => $workspace->label()];
+ $context = ['@type' => $workspace->bundle(), '%info' => $workspace->label()];
+ $logger = $this->logger('workspace');
+
+ if ($status == SAVED_UPDATED) {
+ $logger->notice('@type: updated %info.', $context);
+ drupal_set_message($this->t('Workspace %info has been updated.', $info));
+ }
+ else {
+ $logger->notice('@type: added %info.', $context);
+ drupal_set_message($this->t('Workspace %info has been created.', $info));
+ }
+
+ if ($workspace->id()) {
+ $form_state->setValue('id', $workspace->id());
+ $form_state->set('id', $workspace->id());
+ $redirect = $this->currentUser()->hasPermission('administer workspaces') ? $workspace->toUrl('collection') : Url::fromRoute('');
+ $form_state->setRedirectUrl($redirect);
+ }
+ else {
+ drupal_set_message($this->t('The workspace could not be saved.'), 'error');
+ $form_state->setRebuild();
+ }
+ }
+
+}
diff --git a/core/modules/workspace/src/Entity/ReplicationLog.php b/core/modules/workspace/src/Entity/ReplicationLog.php
new file mode 100644
index 0000000000..f1415e7553
--- /dev/null
+++ b/core/modules/workspace/src/Entity/ReplicationLog.php
@@ -0,0 +1,140 @@
+get('history')->getValue();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setHistory($history) {
+ $histories = array_merge([$history], $this->getHistory());
+ $this->set('history', $histories);
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSessionId() {
+ return $this->get('session_id')->value;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setSessionId($session_id) {
+ $this->set('session_id', $session_id);
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSourceLastSeq() {
+ return $this->get('source_last_seq')->value;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setSourceLastSeq($source_last_seq) {
+ $this->set('source_last_seq', $source_last_seq);
+ return $this;
+ }
+
+ /**
+ * @param $id string
+ * @return \Drupal\workspace\Entity\ReplicationLogInterface
+ */
+ public static function loadOrCreate($id) {
+ $entities = \Drupal::entityTypeManager()
+ ->getStorage('replication_log')
+ ->loadByProperties(['uuid' => $id]);
+ if (!empty($entities)) {
+ return reset($entities);
+ }
+ else {
+ return static::create(['uuid' => $id]);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
+ $fields['id'] = BaseFieldDefinition::create('integer')
+ ->setLabel(t('ID'))
+ ->setDescription(t('The ID of the replication log entity.'))
+ ->setReadOnly(TRUE)
+ ->setSetting('unsigned', TRUE);
+
+ $fields['uuid'] = BaseFieldDefinition::create('uuid')
+ ->setLabel(t('UUID'))
+ ->setDescription(t('The UUID of the replication log entity.'))
+ ->setReadOnly(TRUE);
+
+ $fields['revision_id'] = BaseFieldDefinition::create('integer')
+ ->setLabel(t('Revision ID'))
+ ->setDescription(t('The local revision ID of the replication log entity.'))
+ ->setReadOnly(TRUE)
+ ->setSetting('unsigned', TRUE);
+
+ $fields['history'] = BaseFieldDefinition::create('replication_history')
+ ->setLabel(t('Replication log history'))
+ ->setDescription(t('The version id of the test entity.'))
+ ->setReadOnly(TRUE)
+ ->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+ $fields['session_id'] = BaseFieldDefinition::create('uuid')
+ ->setLabel(t('Replication session ID'))
+ ->setDescription(t('The unique session ID of the last replication. Shortcut to the session_id in the last history item.'))
+ ->setReadOnly(TRUE);
+
+ $fields['source_last_seq'] = BaseFieldDefinition::create('string')
+ ->setLabel(t('Last processed checkpoint'))
+ ->setDescription(t('The last processed checkpoint. Shortcut to the source_last_seq in the last history item.'))
+ ->setReadOnly(TRUE);
+
+ $fields['ok'] = BaseFieldDefinition::create('boolean')
+ ->setLabel(t('ok'))
+ ->setDescription(t('Replication status'))
+ ->setDefaultValue(TRUE)
+ ->setReadOnly(TRUE);
+
+ return $fields;
+ }
+
+}
diff --git a/core/modules/workspace/src/Entity/ReplicationLogInterface.php b/core/modules/workspace/src/Entity/ReplicationLogInterface.php
new file mode 100644
index 0000000000..20a39aa547
--- /dev/null
+++ b/core/modules/workspace/src/Entity/ReplicationLogInterface.php
@@ -0,0 +1,63 @@
+setLabel(new TranslatableMarkup('Workaspace ID'))
+ ->setDescription(new TranslatableMarkup('The workspace ID.'))
+ ->setSetting('max_length', 128)
+ ->setRequired(TRUE)
+ ->addPropertyConstraints('value', ['Regex' => ['pattern' => '/^[\da-z_$()+-\/]*$/']]);
+
+ $fields['label'] = BaseFieldDefinition::create('string')
+ ->setLabel(new TranslatableMarkup('Workaspace name'))
+ ->setDescription(new TranslatableMarkup('The workspace name.'))
+ ->setRevisionable(TRUE)
+ ->setSetting('max_length', 128)
+ ->setRequired(TRUE);
+
+ $fields['uid'] = BaseFieldDefinition::create('entity_reference')
+ ->setLabel(new TranslatableMarkup('Owner'))
+ ->setDescription(new TranslatableMarkup('The workspace owner.'))
+ ->setRevisionable(TRUE)
+ ->setSetting('target_type', 'user')
+ ->setDefaultValueCallback('Drupal\workspace\Entity\Workspace::getCurrentUserId');
+
+ $fields['changed'] = BaseFieldDefinition::create('changed')
+ ->setLabel(new TranslatableMarkup('Changed'))
+ ->setDescription(new TranslatableMarkup('The time that the workspace was last edited.'))
+ ->setRevisionable(TRUE);
+
+ $fields['created'] = BaseFieldDefinition::create('created')
+ ->setLabel(new TranslatableMarkup('Created'))
+ ->setDescription(new TranslatableMarkup('The UNIX timestamp of when the workspace has been created.'));
+
+ $fields['upstream'] = BaseFieldDefinition::create('string')
+ ->setLabel(new TranslatableMarkup('Assign default target workspace'))
+ ->setDescription(new TranslatableMarkup('The workspace to push to and pull from.'))
+ ->setRevisionable(TRUE)
+ ->setRequired(TRUE)
+ ->setDefaultValueCallback('Drupal\workspace\Entity\Workspace::getActiveWorkspaceId');
+
+ return $fields;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getUpdateSeq() {
+ return \Drupal::service('workspace.entity_index.sequence')->useWorkspace($this->id())->getLastSequenceId();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setCreatedTime($created) {
+ $this->set('created', (int) $created);
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getStartTime() {
+ return $this->get('created')->value;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getOwner() {
+ return $this->get('uid')->entity;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setOwner(UserInterface $account) {
+ $this->set('uid', $account->id());
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getOwnerId() {
+ return $this->get('uid')->target_id;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setOwnerId($uid) {
+ $this->set('uid', $uid);
+ return $this;
+ }
+
+ /**
+ * Default value callback for 'uid' base field definition.
+ *
+ * @see ::baseFieldDefinitions()
+ *
+ * @return array
+ * An array of default values.
+ */
+ public static function getCurrentUserId() {
+ return [\Drupal::currentUser()->id()];
+ }
+
+ /**
+ * Default value callback for 'upstream' base field definition.
+ *
+ * @see ::baseFieldDefinitions()
+ *
+ * @return array
+ * An array of default values.
+ */
+ public static function getActiveWorkspaceId() {
+ return ['workspace:' . \Drupal::service('workspace.manager')->getActiveWorkspace()];
+ }
+
+}
diff --git a/core/modules/workspace/src/Entity/WorkspaceInterface.php b/core/modules/workspace/src/Entity/WorkspaceInterface.php
new file mode 100644
index 0000000000..93cc55d37a
--- /dev/null
+++ b/core/modules/workspace/src/Entity/WorkspaceInterface.php
@@ -0,0 +1,36 @@
+entityTypeManager = $entity_type_manager;
+ $this->workspaceManager = $workspace_manager;
+ $this->defaultWorkspaceId = $default_workspace;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function create(ContainerInterface $container) {
+ return new static(
+ $container->get('entity_type.manager'),
+ $container->get('workspace.manager'),
+ $container->getParameter('workspace.default')
+ );
+ }
+ }
+
+ /**
+ * Hook bridge;
+ *
+ * @see hook_entity_access()
+ *
+ * @param EntityInterface $entity
+ * @param string $operation
+ * @param AccountInterface $account
+ *
+ * @return AccessResult
+ */
+ public function entityAccess(EntityInterface $entity, $operation, AccountInterface $account) {
+ // Workspaces themselves are handled by another hook. Ignore them here.
+ if ($entity->getEntityTypeId() == 'workspace') {
+ return AccessResult::neutral();
+ }
+
+ /** @var \Drupal\workspace\WorkspaceManagerInterface $workspace_manager */
+ $workspace_manager = \Drupal::service('workspace.manager');
+ if ($workspace_manager->entityCanBelongToWorkspaces($entity)
+ && $entity->workspace->target_id != \Drupal::getContainer()->getParameter('workspace.default')) {
+ $active_workspace = $workspace_manager->getActiveWorkspace();
+ $result = \Drupal::entityTypeManager()
+ ->getStorage('content_workspace')
+ ->getQuery()
+ ->allRevisions()
+ ->condition('content_entity_type_id', $entity->getEntityTypeId())
+ ->condition('content_entity_id', $entity->id())
+ ->condition('content_entity_revision_id', $entity->getRevisionId())
+ ->condition('workspace', $active_workspace)
+ ->execute();
+ if (empty($result)) {
+ return AccessResult::forbidden();
+ }
+ }
+
+ return $this->bypassAccessResult($account);
+ }
+
+ /**
+ * Hook bridge;
+ *
+ * @see hook_entity_create_access()
+ *
+ * @param AccountInterface $account
+ * @param array $context
+ * @param $entity_bundle
+ *
+ * @return \Drupal\Core\Access\AccessResult
+ */
+ public function entityCreateAccess(AccountInterface $account, array $context, $entity_bundle) {
+
+ // Workspaces themselves are handled by another hook. Ignore them here.
+ if ($entity_bundle == 'workspace') {
+ return AccessResult::neutral();
+ }
+
+ return $this->bypassAccessResult($account);
+ }
+
+ /**
+ * @param AccountInterface $account
+ * @return AccessResult
+ */
+ protected function bypassAccessResult(AccountInterface $account) {
+ // This approach assumes that the current "global" active workspace is
+ // correct, ie, if you're "in" a given workspace then you get ALL THE PERMS
+ // to ALL THE THINGS! That's why this is a dangerous permission.
+ $active_workspace = $this->workspaceManager->getActiveWorkspace(TRUE);
+
+ return AccessResult::allowedIfHasPermission($account, 'bypass_entity_access_workspace_' . $active_workspace->id())
+ ->orIf(
+ AccessResult::allowedIf($active_workspace->getOwnerId() == $account->id())
+ ->andIf(AccessResult::allowedIfHasPermission($account, 'bypass entity access own workspace'))
+ );
+ }
+
+ /**
+ * Returns an array of workspace-specific permissions.
+ *
+ * Note: This approach assumes that a site will have only a small number
+ * of workspace entities, under a dozen. If there are many dozens of
+ * workspaces defined then this approach will have scaling issues.
+ *
+ * @return array
+ * The workspace permissions.
+ */
+ public function workspacePermissions() {
+ $perms = [];
+
+ foreach ($this->getAllWorkspaces() as $workspace) {
+ $perms += $this->createWorkspaceViewPermission($workspace)
+ + $this->createWorkspaceEditPermission($workspace)
+ + $this->createWorkspaceDeletePermission($workspace)
+ + $this->createWorkspaceBypassPermission($workspace);
+ }
+
+ return $perms;
+ }
+
+ /**
+ * Returns a list of all workspace entities in the system.
+ *
+ * @return \Drupal\workspace\Entity\WorkspaceInterface[]
+ * An array of workspace entities, keyed by their IDs.
+ */
+ protected function getAllWorkspaces() {
+ return $this->entityTypeManager->getStorage('workspace')->loadMultiple();
+ }
+
+ /**
+ * Derives the view permission for a specific workspace.
+ *
+ * @param \Drupal\workspace\Entity\WorkspaceInterface $workspace
+ * The workspace from which to derive the permission.
+ * @return array
+ * A single-item array with the permission to define.
+ */
+ protected function createWorkspaceViewPermission(WorkspaceInterface $workspace) {
+ $perms['view_workspace_' . $workspace->id()] = [
+ 'title' => $this->t('View the %workspace workspace', ['%workspace' => $workspace->label()]),
+ 'description' => $this->t('View the %workspace workspace and content within it', ['%workspace' => $workspace->label()]),
+ ];
+
+ return $perms;
+ }
+
+ /**
+ * Derives the edit permission for a specific workspace.
+ *
+ * @param \Drupal\workspace\Entity\WorkspaceInterface $workspace
+ * The workspace from which to derive the permission.
+ * @return array
+ * A single-item array with the permission to define.
+ */
+ protected function createWorkspaceEditPermission(WorkspaceInterface $workspace) {
+ $perms['update_workspace_' . $workspace->id()] = [
+ 'title' => $this->t('Edit the %workspace workspace', ['%workspace' => $workspace->label()]),
+ 'description' => $this->t('Edit the %workspace workspace itself', ['%workspace' => $workspace->label()]),
+ ];
+
+ return $perms;
+ }
+
+ /**
+ * Derives the delete permission for a specific workspace.
+ *
+ * @param \Drupal\workspace\Entity\WorkspaceInterface $workspace
+ * The workspace from which to derive the permission.
+ * @return array
+ * A single-item array with the permission to define.
+ */
+ protected function createWorkspaceDeletePermission(WorkspaceInterface $workspace) {
+ $perms['delete_workspace_' . $workspace->id()] = [
+ 'title' => $this->t('Delete the %workspace workspace', ['%workspace' => $workspace->label()]),
+ 'description' => $this->t('View the %workspace workspace and all content within it', ['%workspace' => $workspace->label()]),
+ ];
+
+ return $perms;
+ }
+
+ /**
+ * Derives the delete permission for a specific workspace.
+ *
+ * @param \Drupal\workspace\Entity\WorkspaceInterface $workspace
+ * The workspace from which to derive the permission.
+ * @return array
+ * A single-item array with the permission to define.
+ */
+ protected function createWorkspaceBypassPermission(WorkspaceInterface $workspace) {
+ $perms['bypass_entity_access_workspace_' . $workspace->id()] = [
+ 'title' => $this->t('Bypass content entity access in %workspace workspace', ['%workspace' => $workspace->label()]),
+ 'description' => $this->t('Allow all Edit/Update/Delete permissions for all content in the %workspace workspace', ['%workspace' => $workspace->label()]),
+ 'restrict access' => TRUE,
+ ];
+
+ return $perms;
+ }
+
+}
diff --git a/core/modules/workspace/src/Form/DeploymentForm.php b/core/modules/workspace/src/Form/DeploymentForm.php
new file mode 100644
index 0000000000..571110affe
--- /dev/null
+++ b/core/modules/workspace/src/Form/DeploymentForm.php
@@ -0,0 +1,92 @@
+id() == $workspace->get('upstream')->value) {
+ return [];
+ }
+
+ $upstream_plugin = \Drupal::service('workspace.upstream_manager')->createInstance($workspace->get('upstream')->value);
+ $form['workspace_id'] = [
+ '#type' => 'hidden',
+ '#value' => $workspace->id(),
+ ];
+
+ $form['deploy'] = [
+ '#type' => 'submit',
+ '#value' => $this->t('Deploy to %upstream', ['%upstream' => $upstream_plugin->getLabel()]),
+ '#attributes' => [
+ 'class' => ['primary', 'button--primary'],
+ ],
+ '#weight' => 1,
+ ];
+
+ $form['update'] = [
+ '#type' => 'submit',
+ '#value' => $this->t('Update'),
+ '#submit' => ['::updateHandler'],
+ '#weight' => 0,
+ ];
+
+ return $form;
+ }
+
+ /**
+ * @param array $form
+ * @param \Drupal\Core\Form\FormStateInterface $form_state
+ */
+ public function updateHandler(array &$form, FormStateInterface $form_state) {
+ $workspace = Workspace::load($form_state->getValue('workspace_id'));
+ $upstream_manager = \Drupal::service('workspace.upstream_manager');
+ try {
+ \Drupal::service('workspace.replication_manager')->replicate(
+ $upstream_manager->createInstance($workspace->get('upstream')->value),
+ $upstream_manager->createInstance('workspace:' . $workspace->id())
+ );
+ drupal_set_message('Update successful.');
+ }
+ catch (\Exception $e) {
+ drupal_set_message('Deployment error', 'error');
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function submitForm(array &$form, FormStateInterface $form_state) {
+ $workspace = Workspace::load($form_state->getValue('workspace_id'));
+ $upstream_manager = \Drupal::service('workspace.upstream_manager');
+ try {
+ \Drupal::service('workspace.replication_manager')->replicate(
+ $upstream_manager->createInstance('workspace:' . $workspace->id()),
+ $upstream_manager->createInstance($workspace->get('upstream')->value)
+ );
+ drupal_set_message('Successful deployment.');
+ }
+ catch (\Exception $e) {
+ drupal_set_message('Deployment error', 'error');
+ }
+ }
+
+}
diff --git a/core/modules/workspace/src/Form/WorkspaceActivateForm.php b/core/modules/workspace/src/Form/WorkspaceActivateForm.php
new file mode 100644
index 0000000000..1ccdda6150
--- /dev/null
+++ b/core/modules/workspace/src/Form/WorkspaceActivateForm.php
@@ -0,0 +1,46 @@
+ 'hidden',
+ '#value' => $workspace->id(),
+ ];
+
+ $form['instruction'] = [
+ '#type' => 'markup',
+ '#prefix' => '
',
+ '#markup' => $this->t('Would you like to activate the %workspace workspace?', ['%workspace' => $workspace->label()]),
+ '#suffix' => '
',
+ ];
+
+ $form['submit'] = [
+ '#type' => 'submit',
+ '#value' => 'Activate',
+ ];
+
+ $form['#title'] = $this->t('Activate workspace %label', ['%label' => $workspace->label()]);
+
+ return $form;
+ }
+
+}
diff --git a/core/modules/workspace/src/Form/WorkspaceActivateFormBase.php b/core/modules/workspace/src/Form/WorkspaceActivateFormBase.php
new file mode 100644
index 0000000000..619359be01
--- /dev/null
+++ b/core/modules/workspace/src/Form/WorkspaceActivateFormBase.php
@@ -0,0 +1,81 @@
+get('workspace.manager'),
+ $container->get('entity_type.manager')
+ );
+ }
+
+ public function __construct(WorkspaceManagerInterface $workspace_manager, EntityTypeManagerInterface $entity_type_manager) {
+ $this->workspaceManager = $workspace_manager;
+ $this->entityTypeManager = $entity_type_manager;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function validateForm(array &$form, FormStateInterface $form_state) {
+ $id = $form_state->getValue('workspace_id');
+
+ // Ensure we are given an ID.
+ if (!$id) {
+ $form_state->setErrorByName('workspace_id', 'The workspace ID is required.');
+ }
+
+ // Ensure the workspace by that id exists.
+ /** @var \Drupal\workspace\Entity\WorkspaceInterface $workspace */
+ $workspace = $this->entityTypeManager->getStorage('workspace')->load($id);
+ if (!$workspace) {
+ $form_state->setErrorByName('workspace_id', 'This workspace no longer exists.');
+ }
+ }
+
+ /**
+ * @inheritDoc
+ */
+ public function submitForm(array &$form, FormStateInterface $form_state) {
+ $id = $form_state->getValue('workspace_id');
+ /** @var \Drupal\workspace\Entity\WorkspaceInterface $workspace */
+ $workspace = $this->entityTypeManager->getStorage('workspace')->load($id);
+
+ try {
+ $this->workspaceManager->setActiveWorkspace($workspace);
+ $form_state->setRedirect('');
+ }
+ catch (\Exception $e) {
+ watchdog_exception('Workspace', $e);
+ drupal_set_message($e->getMessage(), 'error');
+ }
+ }
+
+}
diff --git a/core/modules/workspace/src/Form/WorkspaceSwitcherForm.php b/core/modules/workspace/src/Form/WorkspaceSwitcherForm.php
new file mode 100644
index 0000000000..2ad2cafa92
--- /dev/null
+++ b/core/modules/workspace/src/Form/WorkspaceSwitcherForm.php
@@ -0,0 +1,58 @@
+ 'hidden',
+ '#value' => $workspace->id(),
+ ];
+
+ $form['submit'] = [
+ '#type' => 'submit',
+ '#value' => $workspace->label(),
+ ];
+
+ $active_workspace = $this->workspaceManager->getActiveWorkspace();
+ if ($active_workspace === $workspace->id()) {
+ $form['submit']['#attributes']['class'] = ['is-active'];
+ }
+
+ return $form;
+ }
+
+}
diff --git a/core/modules/workspace/src/Index/SequenceIndex.php b/core/modules/workspace/src/Index/SequenceIndex.php
new file mode 100644
index 0000000000..aaa0ed567a
--- /dev/null
+++ b/core/modules/workspace/src/Index/SequenceIndex.php
@@ -0,0 +1,111 @@
+sortedSetFactory = $sorted_set_factory;
+ $this->workspaceManager = $workspace_manager;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function useWorkspace($id) {
+ $this->workspaceId = $id;
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function add(ContentEntityInterface $entity) {
+ $workspace_id = NULL;
+ $record = $this->buildRecord($entity);
+ if ($entity->getEntityType()->get('workspace') === FALSE) {
+ $workspace_id = 0;
+ }
+ $this->sortedSetStore($workspace_id)->add($record['seq'], $record);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getRange($start, $stop = NULL, $inclusive = TRUE) {
+ $range = $this->sortedSetStore()->getRange($start, $stop, $inclusive);
+ if (empty($range)) {
+ $range = $this->sortedSetStore(0)->getRange($start, $stop, $inclusive);
+ }
+ return $range;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getLastSequenceId() {
+ $max_key = $this->sortedSetStore()->getMaxKey();
+ if (empty($max_key)) {
+ $max_key = $this->sortedSetStore(0)->getMaxKey();
+ }
+ return $max_key;
+ }
+
+ /**
+ * @param $workspace_id
+ *
+ * @return \Drupal\workspace\KeyValueStore\KeyValueStoreSortedSetInterface
+ */
+ protected function sortedSetStore($workspace_id = NULL) {
+ if (!$workspace_id) {
+ $workspace_id = $this->workspaceId ?: $this->workspaceManager->getActiveWorkspace()->id();
+ }
+ return $this->sortedSetFactory->get($this->collectionPrefix . $workspace_id);
+ }
+
+ /**
+ * @param \Drupal\Core\Entity\ContentEntityInterface $entity
+ * @return array
+ */
+ protected function buildRecord(ContentEntityInterface $entity) {
+ return [
+ 'entity_type_id' => $entity->getEntityTypeId(),
+ 'entity_id' => $entity->id(),
+ 'entity_uuid' => $entity->uuid(),
+ 'revision_id' => $entity->getRevisionId(),
+ 'seq' => (int) (microtime(TRUE) * 1000000),
+ ];
+ }
+
+}
diff --git a/core/modules/workspace/src/Index/SequenceIndexInterface.php b/core/modules/workspace/src/Index/SequenceIndexInterface.php
new file mode 100644
index 0000000000..0c58e2f2ca
--- /dev/null
+++ b/core/modules/workspace/src/Index/SequenceIndexInterface.php
@@ -0,0 +1,40 @@
+collection = $collection;
+ $this->serializer = $serializer;
+ $this->connection = $connection;
+ $this->table = $table;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function add($key, $value) {
+ return $this->addMultiple([[$key => $value]]);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function addMultiple(array $pairs) {
+ foreach ($pairs as $pair) {
+ foreach ($pair as $key => $value) {
+ $try_again = FALSE;
+ try {
+ $encoded_value = $this->serializer->encode($value);
+ $this->connection->merge($this->table)
+ ->fields([
+ 'collection' => $this->collection,
+ 'name' => $key,
+ 'value' => $encoded_value,
+ ])
+ ->condition('collection', $this->collection)
+ ->condition('value', $encoded_value)
+ ->execute();
+ }
+ catch (\Exception $e) {
+ // If there was an exception, try to create the table.
+ if (!$try_again = $this->ensureTableExists()) {
+ // If the exception happened for other reason than the missing
+ // table, propagate the exception.
+ throw $e;
+ }
+ }
+ // Now that the table has been created, try again if necessary.
+ if ($try_again) {
+ $this->add($key, $value);
+ }
+ }
+ }
+ return $this;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getCount() {
+ try {
+ return $this->connection->query('SELECT COUNT(*) FROM {' . $this->connection->escapeTable($this->table) . '} WHERE collection = :collection', [
+ ':collection' => $this->collection
+ ])->fetchField();
+ }
+ catch (\Exception $e) {
+ $this->catchException($e);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getRange($start, $stop = NULL) {
+ try {
+ $query = $this->connection->select($this->table, 't')
+ ->fields('t', ['value'])
+ ->orderBy('name', 'ASC')
+ ->condition('collection', $this->collection)
+ ->condition('name', $start, '>=');
+
+ if (is_int($stop)) {
+ $query->condition('name', $stop, '<=');
+ }
+
+ $values = [];
+ foreach ($query->execute() as $item) {
+ $values[] = $this->serializer->decode($item->value);
+ }
+ return $values;
+ }
+ catch (\Exception $e) {
+ $this->catchException($e);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getMaxKey() {
+ try {
+ return $this->connection->query('SELECT MAX(name) FROM {' . $this->connection->escapeTable($this->table) . '} WHERE collection = :collection', [
+ ':collection' => $this->collection
+ ])->fetchField();
+ }
+ catch (\Exception $e) {
+ $this->catchException($e);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getMinKey() {
+ try {
+ return $this->connection->query('SELECT MIN(name) FROM {' . $this->connection->escapeTable($this->table) . '} WHERE collection = :collection', [
+ ':collection' => $this->collection
+ ])->fetchField();
+ }
+ catch (\Exception $e) {
+ $this->catchException($e);
+ }
+ }
+
+ /**
+ * Checks if the table exists and creates if not.
+ *
+ * @return bool
+ */
+ protected function ensureTableExists() {
+ try {
+ $database_schema = $this->connection->schema();
+ if (!$database_schema->tableExists($this->table)) {
+ $database_schema->createTable($this->table, $this->schemaDefinition());
+ return TRUE;
+ }
+ }
+ // If the table already exists, then attempting to recreate it will throw an
+ // exception. In this case just catch the exception and do nothing.
+ catch (SchemaObjectExistsException $e) {
+ return TRUE;
+ }
+ return FALSE;
+ }
+
+ /**
+ * Act on an exception when the table might not have been created.
+ *
+ * If the table does not yet exist, that's fine, but if the table exists and
+ * something else caused the exception, then propagate it.
+ *
+ * @param \Exception $e
+ * The exception.
+ *
+ * @throws \Exception
+ */
+ protected function catchException(\Exception $e) {
+ if ($this->connection->schema()->tableExists($this->table)) {
+ throw $e;
+ }
+ }
+
+ /**
+ * The schema definition for the sorted key-value list storage table.
+ *
+ * @return array
+ */
+ protected function schemaDefinition() {
+ return [
+ 'description' => 'Sorted key-value list storage table.',
+ 'fields' => [
+ 'collection' => [
+ 'description' => 'A named collection of key and value pairs.',
+ 'type' => 'varchar',
+ 'length' => 128,
+ 'not null' => TRUE,
+ 'default' => '',
+ ],
+ // KEY is an SQL reserved word, so use 'name' as the key's field name.
+ 'name' => [
+ 'description' => 'The index or score key for the value.',
+ 'type' => 'int',
+ 'not null' => TRUE,
+ 'default' => 0,
+ 'size' => 'big',
+ ],
+ 'value' => [
+ 'description' => 'The value.',
+ 'type' => 'blob',
+ 'not null' => TRUE,
+ 'size' => 'big',
+ ],
+ ],
+ 'indexes' => [
+ 'collection_name' => ['collection', 'name'],
+ ],
+ ];
+ }
+
+}
diff --git a/core/modules/workspace/src/KeyValueStore/KeyValueDatabaseSortedSetFactory.php b/core/modules/workspace/src/KeyValueStore/KeyValueDatabaseSortedSetFactory.php
new file mode 100644
index 0000000000..b85d288bb1
--- /dev/null
+++ b/core/modules/workspace/src/KeyValueStore/KeyValueDatabaseSortedSetFactory.php
@@ -0,0 +1,47 @@
+serializer = $serializer;
+ $this->connection = $connection;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function get($collection) {
+ return new DatabaseStorageSortedSet($collection, $this->serializer, $this->connection);
+ }
+
+}
diff --git a/core/modules/workspace/src/KeyValueStore/KeyValueSortedSetFactory.php b/core/modules/workspace/src/KeyValueStore/KeyValueSortedSetFactory.php
new file mode 100644
index 0000000000..94962594d9
--- /dev/null
+++ b/core/modules/workspace/src/KeyValueStore/KeyValueSortedSetFactory.php
@@ -0,0 +1,18 @@
+ 'a'], [2 => 'b']].
+ *
+ * @param array[] $map
+ * A map of keys and values to add.
+ *
+ * @return $this
+ */
+ public function addMultiple(array $map);
+
+ /**
+ * Get the highest key in a collection.
+ *
+ * @return int
+ * The highest key in the collection.
+ */
+ public function getMaxKey();
+
+ /**
+ * Get the lowest key in in a collection.
+ *
+ * @return int
+ * The lowest key in the collection.
+ */
+ public function getMinKey();
+
+ /**
+ * Get the number of items in a collection.
+ *
+ * @return int
+ * The number of items in a collection.
+ */
+ public function getCount();
+
+ /**
+ * Get multiple items within a range of keys.
+ *
+ * @param int $start
+ * The first key in the range.
+ * @param int $stop
+ * The last key in the range.
+ *
+ * @return array
+ * An array of items within the given range.
+ */
+ public function getRange($start, $stop = NULL);
+
+}
diff --git a/core/modules/workspace/src/Negotiator/DefaultWorkspaceNegotiator.php b/core/modules/workspace/src/Negotiator/DefaultWorkspaceNegotiator.php
new file mode 100644
index 0000000000..f60b6342f7
--- /dev/null
+++ b/core/modules/workspace/src/Negotiator/DefaultWorkspaceNegotiator.php
@@ -0,0 +1,43 @@
+defaultWorkspaceId = $default_workspace_id;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function applies(Request $request) {
+ return TRUE;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getWorkspaceId(Request $request) {
+ return $this->defaultWorkspaceId;
+ }
+
+}
diff --git a/core/modules/workspace/src/Negotiator/ParamWorkspaceNegotiator.php b/core/modules/workspace/src/Negotiator/ParamWorkspaceNegotiator.php
new file mode 100644
index 0000000000..15bb410bcb
--- /dev/null
+++ b/core/modules/workspace/src/Negotiator/ParamWorkspaceNegotiator.php
@@ -0,0 +1,26 @@
+query->get('workspace'));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getWorkspaceId(Request $request) {
+ return $request->query->get('workspace');
+ }
+
+}
diff --git a/core/modules/workspace/src/Negotiator/SessionWorkspaceNegotiator.php b/core/modules/workspace/src/Negotiator/SessionWorkspaceNegotiator.php
new file mode 100644
index 0000000000..81f9d4c100
--- /dev/null
+++ b/core/modules/workspace/src/Negotiator/SessionWorkspaceNegotiator.php
@@ -0,0 +1,77 @@
+currentUser = $current_user;
+ $this->tempstore = $tempstore_factory->get('workspace.negotiator.session');
+ $this->defaultWorkspaceId = $default_workspace_id;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function applies(Request $request) {
+ // This negotiator only applies if the current user is authenticated,
+ // i.e. a session exists.
+ return $this->currentUser->isAuthenticated();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getWorkspaceId(Request $request) {
+ $workspace_id = $this->tempstore->get('active_workspace_id');
+ return $workspace_id ?: $this->defaultWorkspaceId;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function persist(WorkspaceInterface $workspace) {
+ $this->tempstore->set('active_workspace_id', $workspace->id());
+ return parent::persist($workspace);
+ }
+
+}
diff --git a/core/modules/workspace/src/Negotiator/WorkspaceNegotiatorBase.php b/core/modules/workspace/src/Negotiator/WorkspaceNegotiatorBase.php
new file mode 100644
index 0000000000..6ce9e0eaaf
--- /dev/null
+++ b/core/modules/workspace/src/Negotiator/WorkspaceNegotiatorBase.php
@@ -0,0 +1,19 @@
+entityManager = $entity_manager;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function convert($value, $definition, $name, array $defaults) {
+ $entity_type_id = $this->getEntityTypeFromDefaults($definition, $name, $defaults);
+ if ($storage = $this->entityManager->getStorage($entity_type_id)) {
+ $entity = $storage->loadRevision($value);
+ // If the entity type is translatable, ensure we return the proper
+ // translation object for the current context.
+ if ($entity instanceof EntityInterface && $entity instanceof TranslatableInterface) {
+ $entity = $this->entityManager->getTranslationFromContext($entity, NULL, ['operation' => 'entity_upcast']);
+ }
+ return $entity;
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function applies($definition, $name, Route $route) {
+ if (!empty($definition['type']) && strpos($definition['type'], 'entity_revision:') === 0) {
+ $entity_type_id = substr($definition['type'], strlen('entity:'));
+ if (strpos($definition['type'], '{') !== FALSE) {
+ $entity_type_slug = substr($entity_type_id, 1, -1);
+ return $name != $entity_type_slug && in_array($entity_type_slug, $route->compile()->getVariables(), TRUE);
+ }
+ return $this->entityManager->hasDefinition($entity_type_id);
+ }
+ return FALSE;
+ }
+
+ /**
+ * Determines the entity type ID given a route definition and route defaults.
+ *
+ * @param mixed $definition
+ * The parameter definition provided in the route options.
+ * @param string $name
+ * The name of the parameter.
+ * @param array $defaults
+ * The route defaults array.
+ *
+ * @throws \Drupal\Core\ParamConverter\ParamNotConvertedException
+ * Thrown when the dynamic entity type is not found in the route defaults.
+ *
+ * @return string
+ * The entity type ID.
+ */
+ protected function getEntityTypeFromDefaults($definition, $name, array $defaults) {
+ $entity_type_id = substr($definition['type'], strlen('entity_revision:'));
+
+ // If the entity type is dynamic, it will be pulled from the route defaults.
+ if (strpos($entity_type_id, '{') === 0) {
+ $entity_type_slug = substr($entity_type_id, 1, -1);
+ if (!isset($defaults[$entity_type_slug])) {
+ throw new ParamNotConvertedException(sprintf('The "%s" parameter was not converted because the "%s" parameter is missing', $name, $entity_type_slug));
+ }
+ $entity_type_id = $defaults[$entity_type_slug];
+ }
+ return $entity_type_id;
+ }
+
+}
diff --git a/core/modules/workspace/src/Plugin/Block/WorkspaceBlock.php b/core/modules/workspace/src/Plugin/Block/WorkspaceBlock.php
new file mode 100644
index 0000000000..8b87f5aca4
--- /dev/null
+++ b/core/modules/workspace/src/Plugin/Block/WorkspaceBlock.php
@@ -0,0 +1,73 @@
+workspaceManager = $workspace_manager;
+ $this->entityTypeManager = $entity_type_manager;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+ return new static(
+ $configuration,
+ $plugin_id,
+ $plugin_definition,
+ $container->get('workspace.manager'),
+ $container->get('entity_type.manager')
+ );
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function build() {
+ $build = [
+ // @todo the block depending on the toolbar is obscure; find a better way to generate this form
+ '#pre_render' => ['workspace_switcher_toolbar_pre_render'],
+ // This wil get filled in via pre-render.
+ 'workspace_forms' => [],
+ '#attached' => [
+ 'library' => [
+ 'workspace/drupal.workspace.switcher',
+ ],
+ ],
+ '#cache' => [
+ 'contexts' => $this->entityTypeManager->getDefinition('workspace')->getListCacheContexts(),
+ 'tags' => $this->entityTypeManager->getDefinition('workspace')->getListCacheTags(),
+ ],
+ ];
+ return $build;
+ }
+
+}
diff --git a/core/modules/workspace/src/Plugin/Derivative/Workspace.php b/core/modules/workspace/src/Plugin/Derivative/Workspace.php
new file mode 100644
index 0000000000..e4dcb60f65
--- /dev/null
+++ b/core/modules/workspace/src/Plugin/Derivative/Workspace.php
@@ -0,0 +1,54 @@
+workspaceStorage = $workspace_storage;
+ }
+
+ /**
+ * @inheritDoc
+ */
+ public static function create(ContainerInterface $container, $base_plugin_id) {
+ return new static(
+ $container->get('entity_type.manager')->getStorage('workspace')
+ );
+ }
+
+ /**
+ * Add a workspace plugin per workspace, with an ID in the format
+ * 'workspace:{id}', for example 'workspace:live'.
+ *
+ * {@inheritdoc}
+ */
+ public function getDerivativeDefinitions($base_plugin_definition) {
+ $workspaces = $this->workspaceStorage->loadMultiple();
+ foreach ($workspaces as $workspace) {
+ $this->derivatives[$workspace->id()] = $base_plugin_definition;
+ $this->derivatives[$workspace->id()]['id'] = $base_plugin_definition['id'] . PluginBase::DERIVATIVE_SEPARATOR . $workspace->id();
+ }
+ return $this->derivatives;
+ }
+
+}
diff --git a/core/modules/workspace/src/Plugin/Field/FieldType/ReplicationHistoryItem.php b/core/modules/workspace/src/Plugin/Field/FieldType/ReplicationHistoryItem.php
new file mode 100644
index 0000000000..4c96eccb99
--- /dev/null
+++ b/core/modules/workspace/src/Plugin/Field/FieldType/ReplicationHistoryItem.php
@@ -0,0 +1,155 @@
+setLabel(t('Write failures'))
+ ->setDescription(t('Number of failed document writes'))
+ ->setRequired(FALSE);
+
+ $properties['docs_read'] = DataDefinition::create('integer')
+ ->setLabel(t('Documents read'))
+ ->setDescription(t('Number of documents read.'))
+ ->setRequired(FALSE);
+
+ $properties['docs_written'] = DataDefinition::create('integer')
+ ->setLabel(t('Documents written'))
+ ->setDescription(t('Number of documents written.'))
+ ->setRequired(FALSE);
+
+ $properties['end_last_seq'] = DataDefinition::create('integer')
+ ->setLabel(t('End sequence'))
+ ->setDescription(t('Sequence ID where the replication ended.'))
+ ->setRequired(FALSE);
+
+ $properties['end_time'] = DataDefinition::create('datetime_iso8601')
+ ->setLabel(t('End time'))
+ ->setDescription(t('Date and time when replication ended.'))
+ ->setRequired(FALSE);
+
+ $properties['missing_checked'] = DataDefinition::create('integer')
+ ->setLabel(t('Missing checked'))
+ ->setDescription(t('Number of missing documents checked.'))
+ ->setRequired(FALSE);
+
+ $properties['missing_found'] = DataDefinition::create('integer')
+ ->setLabel(t('Missing found'))
+ ->setDescription(t('Number of missing documents found.'))
+ ->setRequired(FALSE);
+
+ $properties['recorded_seq'] = DataDefinition::create('integer')
+ ->setLabel(t('Recorded sequence'))
+ ->setDescription(t('Recorded intermediate sequence.'))
+ ->setRequired(FALSE);
+
+ $properties['session_id'] = DataDefinition::create('string')
+ ->setLabel(t('Session ID'))
+ ->setDescription(t('Unique session ID for the replication.'))
+ ->setRequired(TRUE);
+
+ $properties['start_last_seq'] = DataDefinition::create('integer')
+ ->setLabel(t('Start sequence'))
+ ->setDescription(t('Sequence ID where the replication started.'))
+ ->setRequired(FALSE);
+
+ $properties['start_time'] = DataDefinition::create('datetime_iso8601')
+ ->setLabel(t('Start time'))
+ ->setDescription(t('Date and time when replication started.'))
+ ->setRequired(FALSE);
+
+ return $properties;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function schema(FieldStorageDefinitionInterface $field_definition) {
+ return [
+ 'columns' => [
+ 'doc_write_failures' => [
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => FALSE,
+ ],
+ 'docs_read' => [
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => FALSE,
+ ],
+ 'docs_written' => [
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => FALSE,
+ ],
+ 'end_last_seq' => [
+ 'type' => 'int',
+ 'size' => 'big',
+ 'not null' => FALSE,
+ ],
+ 'end_time' => [
+ 'type' => 'varchar',
+ 'length' => 50,
+ 'not null' => FALSE,
+ ],
+ 'missing_checked' => [
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => FALSE,
+ ],
+ 'missing_found' => [
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => FALSE,
+ ],
+ 'recorded_seq' => [
+ 'type' => 'int',
+ 'size' => 'big',
+ 'not null' => FALSE,
+ 'default' => 0,
+ ],
+ 'session_id' => [
+ 'type' => 'varchar',
+ 'length' => 128,
+ 'not null' => TRUE,
+ ],
+ 'start_last_seq' => [
+ 'type' => 'int',
+ 'size' => 'big',
+ 'not null' => FALSE,
+ ],
+ 'start_time' => [
+ 'type' => 'varchar',
+ 'length' => 50,
+ 'not null' => FALSE,
+ ],
+ ],
+ ];
+ }
+
+}
diff --git a/core/modules/workspace/src/Plugin/Field/FieldType/ReplicationHistoryItemList.php b/core/modules/workspace/src/Plugin/Field/FieldType/ReplicationHistoryItemList.php
new file mode 100644
index 0000000000..6d7985b153
--- /dev/null
+++ b/core/modules/workspace/src/Plugin/Field/FieldType/ReplicationHistoryItemList.php
@@ -0,0 +1,7 @@
+ 'workspace',
+ ] + parent::defaultStorageSettings();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
+ $properties = parent::propertyDefinitions($field_definition);
+ $properties['status'] = DataDefinition::create('boolean')
+ ->setLabel(t('Status'))
+ ->setRequired(TRUE);
+ return $properties;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function schema(FieldStorageDefinitionInterface $field_definition) {
+ $schema = parent::schema($field_definition);
+ $schema['columns']['status'] = ['type' => 'int', 'size' => 'tiny'];
+ return $schema;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function applyDefaultValue($notify = TRUE) {
+ $workspace_id = \Drupal::service('workspace.manager')->getActiveWorkspace();
+ $entity = $this->getEntity();
+ $this->setValue(['target_id' => $workspace_id, 'status' => $entity->isPublished()], $notify);
+ return $this;
+ }
+
+}
diff --git a/core/modules/workspace/src/Plugin/Upstream/Workspace.php b/core/modules/workspace/src/Plugin/Upstream/Workspace.php
new file mode 100644
index 0000000000..5fe2b8ecc2
--- /dev/null
+++ b/core/modules/workspace/src/Plugin/Upstream/Workspace.php
@@ -0,0 +1,64 @@
+workspace = $entity_type_manager->getStorage('workspace')->load($this->getDerivativeId());
+ }
+
+ /**
+ * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
+ * @param array $configuration
+ * @param string $plugin_id
+ * @param mixed $plugin_definition
+ *
+ * @return static
+ */
+ public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+ return new static(
+ $configuration,
+ $plugin_id,
+ $plugin_definition,
+ $container->get('entity_type.manager')
+ );
+ }
+
+ /**
+ * @inheritDoc
+ */
+ public function getLabel() {
+ return $this->workspace->label();
+ }
+
+}
diff --git a/core/modules/workspace/src/Replication/DefaultReplicator.php b/core/modules/workspace/src/Replication/DefaultReplicator.php
new file mode 100644
index 0000000000..ed44738b51
--- /dev/null
+++ b/core/modules/workspace/src/Replication/DefaultReplicator.php
@@ -0,0 +1,165 @@
+workspaceManager = $workspace_manager;
+ $this->changesFactory = $changes_factory;
+ $this->entityTypeManager = $entity_type_manager;
+ $this->sequenceIndex = $sequence_index;
+ }
+
+ /**
+ * Only use this replicator if the source and target are workspaces. The
+ * Upstream plugin ID would be something like 'workspace:live' for the live
+ * workspace.
+ *
+ * {@inheritdoc}
+ */
+ public function applies(UpstreamInterface $source, UpstreamInterface $target) {
+ list($source_plugin, $source_id) = explode(':', $source->getPluginId());
+ list($target_plugin, $target_id) = explode(':', $target->getPluginId());
+ if ($source_plugin == 'workspace' && $target_plugin == 'workspace'
+ && !empty($source_id) && !empty($target_id)) {
+ return TRUE;
+ }
+ return FALSE;
+ }
+
+ /**
+ * Replicating content from one workspace to another on the same site roughly
+ * following the same protocol as CouchDB replication
+ * (http://docs.couchdb.org/en/2.1.0/replication/protocol.html).
+ *
+ * {@inheritdoc}
+ */
+ public function replicate(UpstreamInterface $source, UpstreamInterface $target) {
+ list($source_plugin, $source_id) = explode(':', $source->getPluginId());
+ list($target_plugin, $target_id) = explode(':', $target->getPluginId());
+ $source = Workspace::load($source_id);
+ $target = Workspace::load($target_id);
+ $replication_id = \md5($source->id() . $target->id());
+ $start_time = new \DateTime();
+ $sessionId = \md5((\microtime(TRUE) * 1000000));
+ $replication_log = ReplicationLog::loadOrCreate($replication_id);
+ $current_active = $this->workspaceManager->getActiveWorkspace(TRUE);
+
+ // Set the source as the active workspace.
+ $this->workspaceManager->setActiveWorkspace($source);
+
+ // Get changes for the current workspace.
+ $history = $replication_log->getHistory();
+ $last_seq = isset($history[0]['recorded_seq']) ? $history[0]['recorded_seq'] : 0;
+ $changes = $this->changesFactory->get($source)->lastSeq($last_seq)->getNormal();
+ $rev_diffs = [];
+ foreach ($changes as $change) {
+ foreach ($change['changes'] as $change_item) {
+ $rev_diffs[$change['type']][] = $change_item['rev'];
+ }
+ }
+
+ // Get revision diff between source and target
+ $content_workspace_ids = [];
+ foreach ($rev_diffs as $entity_type_id => $revs) {
+ $content_workspace_ids[$entity_type_id] = $this->entityTypeManager
+ ->getStorage('content_workspace')
+ ->getQuery()
+ ->allRevisions()
+ ->condition('content_entity_type_id', $entity_type_id)
+ ->condition('content_entity_revision_id', $revs, 'IN')
+ ->condition('workspace', $target->id())
+ ->execute();
+ }
+ foreach ($content_workspace_ids as $entity_type_id => $ids) {
+ foreach ($ids as $id) {
+ $key = array_search($id, $rev_diffs[$entity_type_id]);
+ if (isset($key)) {
+ unset($rev_diffs[$entity_type_id][$key]);
+ }
+ }
+ }
+
+ $entities = [];
+ // Load each missing revision.
+ foreach ($rev_diffs as $entity_type_id => $revs) {
+ foreach ($revs as $rev) {
+ /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
+ $entity = $this->entityTypeManager
+ ->getStorage($entity_type_id)
+ ->loadRevision($rev);
+ $entity->isDefaultRevision(TRUE);
+ $entities[] = $entity;
+ }
+ }
+
+ // Before saving set the active workspace to the target.
+ $this->workspaceManager->setActiveWorkspace($target);
+
+ // Save each revision on the target workspace
+ foreach ($entities as $entity) {
+ $entity->save();
+ }
+
+ // Log
+ $this->workspaceManager->setActiveWorkspace($current_active);
+
+ $replication_log->setHistory([
+ 'recorded_seq' => $this->sequenceIndex->useWorkspace($source->id())->getLastSequenceId(),
+ 'start_time' => $start_time->format('D, d M Y H:i:s e'),
+ 'session_id' => $sessionId,
+ ]);
+ $replication_log->save();
+ return $replication_log;
+ }
+
+}
diff --git a/core/modules/workspace/src/Replication/ReplicationInterface.php b/core/modules/workspace/src/Replication/ReplicationInterface.php
new file mode 100644
index 0000000000..d08a4f6958
--- /dev/null
+++ b/core/modules/workspace/src/Replication/ReplicationInterface.php
@@ -0,0 +1,28 @@
+replicators[$priority][] = $replicator;
+ }
+
+ /**
+ * Find all replicators that apply for the source and target upstream plugins
+ * and run the replication for each replicator.
+ *
+ * @param \Drupal\workspace\UpstreamInterface $source
+ * @param \Drupal\workspace\UpstreamInterface $target
+ *
+ * @return \Drupal\workspace\Entity\ReplicationLogInterface
+ */
+ public function replicate(UpstreamInterface $source, UpstreamInterface $target) {
+ foreach ($this->replicators as $replicators) {
+ /** @var \Drupal\workspace\Replication\ReplicationInterface $replicator */
+ foreach ($replicators as $replicator) {
+ if ($replicator->applies($source, $target)) {
+ return $replicator->replicate($source, $target);
+ }
+ }
+ }
+ }
+
+}
diff --git a/core/modules/workspace/src/UpstreamInterface.php b/core/modules/workspace/src/UpstreamInterface.php
new file mode 100644
index 0000000000..4b51d51666
--- /dev/null
+++ b/core/modules/workspace/src/UpstreamInterface.php
@@ -0,0 +1,30 @@
+alterInfo('workspace_upstream_info');
+ $this->setCacheBackend($cache_backend, 'workspace_upstream');
+ }
+
+}
diff --git a/core/modules/workspace/src/WorkspaceAccessControlHandler.php b/core/modules/workspace/src/WorkspaceAccessControlHandler.php
new file mode 100644
index 0000000000..cd01bf02e1
--- /dev/null
+++ b/core/modules/workspace/src/WorkspaceAccessControlHandler.php
@@ -0,0 +1,50 @@
+ ['any' => 'view any workspace', 'own' => 'view own workspace'],
+ 'update' => ['any' => 'edit any workspace', 'own' => 'edit own workspace'],
+ 'delete' => ['any' => 'delete any workspace', 'own' => 'delete own workspace'],
+ ];
+
+ // The default workspace is always viewable, no matter what.
+ $default_workspace = \Drupal::getContainer()->getParameter('workspace.default');
+ $result = AccessResult::allowedIf($operation == 'view' && $entity->id() == $default_workspace)->addCacheableDependency($entity)
+ // Or if the user has permission to access any workspace at all.
+ ->orIf(AccessResult::allowedIfHasPermission($account, $operations[$operation]['any']))
+ // Or if it's their own workspace, and they have permission to access their own workspace.
+ ->orIf(
+ AccessResult::allowedIf($entity->getOwnerId() == $account->id())->addCacheableDependency($entity)
+ ->andIf(AccessResult::allowedIfHasPermission($account, $operations[$operation]['own']))
+ )
+ ->orIf(AccessResult::allowedIfHasPermission($account, $operation . '_workspace_' . $entity->id()));
+
+ return $result;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function checkCreateAccess(AccountInterface $account, array $context, $entity_bundle = NULL) {
+ return AccessResult::allowedIfHasPermission($account, 'create workspace');
+ }
+
+}
diff --git a/core/modules/workspace/src/WorkspaceAccessException.php b/core/modules/workspace/src/WorkspaceAccessException.php
new file mode 100644
index 0000000000..55b58e6a2f
--- /dev/null
+++ b/core/modules/workspace/src/WorkspaceAccessException.php
@@ -0,0 +1,13 @@
+workspaceManager = $workspace_manager;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getLabel() {
+ return t('Workspace');
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getContext() {
+ return 'ws.' . $this->workspaceManager->getActiveWorkspace();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getCacheableMetadata($type = NULL) {
+ return new CacheableMetadata();
+ }
+
+}
diff --git a/core/modules/workspace/src/WorkspaceListBuilder.php b/core/modules/workspace/src/WorkspaceListBuilder.php
new file mode 100644
index 0000000000..d16e238b8d
--- /dev/null
+++ b/core/modules/workspace/src/WorkspaceListBuilder.php
@@ -0,0 +1,105 @@
+workspaceManager = $workspace_manager;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_type) {
+ return new static(
+ $entity_type,
+ $container->get('entity.manager')->getStorage($entity_type->id()),
+ $container->get('workspace.manager')
+ );
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function buildHeader() {
+ $header['label'] = $this->t('Workspace');
+ $header['uid'] = $this->t('Owner');
+ $header['status'] = $this->t('Status');
+
+ return $header + parent::buildHeader();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function buildRow(EntityInterface $entity) {
+ /** @var \Drupal\workspace\Entity\WorkspaceInterface $entity */
+ $row['label'] = $entity->label() . ' (' . $entity->id() . ')';
+ $row['owner'] = $entity->getOwner()->getDisplayname();
+ $active_workspace = $this->workspaceManager->getActiveWorkspace();
+ $row['status'] = $active_workspace == $entity->id() ? $this->t('Active') : $this->t('Inactive');
+
+ return $row + parent::buildRow($entity);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getDefaultOperations(EntityInterface $entity) {
+ /** @var \Drupal\workspace\Entity\WorkspaceInterface $entity */
+ $operations = parent::getDefaultOperations($entity);
+ if (isset($operations['edit'])) {
+ $operations['edit']['query']['destination'] = $entity->toUrl('collection');
+ }
+
+ $active_workspace = $this->workspaceManager->getActiveWorkspace();
+ if ($entity->id() != $active_workspace) {
+ $operations['activate'] = [
+ 'title' => $this->t('Set Active'),
+ 'weight' => 20,
+ 'url' => $entity->toUrl('activate-form', ['query' => ['destination' => $entity->toUrl('collection')]]),
+ ];
+ }
+
+ if ('workspace:' . $entity->id() != $entity->get('upstream')->value) {
+ $operations['deployment'] = [
+ 'title' => $this->t('Deploy content'),
+ 'weight' => 20,
+ 'url' => $entity->toUrl('deployment-form', ['query' => ['destination' => $entity->toUrl('collection')]]),
+ ];
+ }
+
+ return $operations;
+ }
+
+}
diff --git a/core/modules/workspace/src/WorkspaceManager.php b/core/modules/workspace/src/WorkspaceManager.php
new file mode 100644
index 0000000000..ecfc336a09
--- /dev/null
+++ b/core/modules/workspace/src/WorkspaceManager.php
@@ -0,0 +1,184 @@
+requestStack = $request_stack;
+ $this->entityTypeManager = $entity_type_manager;
+ $this->currentUser = $current_user;
+ $this->logger = $logger ?: new NullLogger();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function entityCanBelongToWorkspaces(EntityInterface $entity) {
+ return $this->entityTypeCanBelongToWorkspaces($entity->getEntityType());
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function entityTypeCanBelongToWorkspaces(EntityTypeInterface $entity_type) {
+ if (!in_array($entity_type->id(), $this->blacklist, TRUE)
+ && is_a($entity_type->getClass(), EntityPublishedInterface::class, TRUE)
+ && $entity_type->isRevisionable()) {
+ return TRUE;
+ }
+ $this->blacklist[] = $entity_type->id();
+ return FALSE;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSupportedEntityTypes() {
+ $entity_types = [];
+ foreach ($this->entityTypeManager->getDefinitions() as $entity_type_id => $entity_type) {
+ if ($this->entityTypeCanBelongToWorkspaces($entity_type)) {
+ $entity_types[$entity_type_id] = $entity_type;
+ }
+ }
+ return $entity_types;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function addNegotiator(WorkspaceNegotiatorInterface $negotiator, $priority) {
+ $this->negotiators[$priority][] = $negotiator;
+ $this->sortedNegotiators = NULL;
+ }
+
+ /**
+ * {@inheritdoc}
+ *
+ * @todo {@link https://www.drupal.org/node/2600382 Access check.}
+ */
+ public function getActiveWorkspace($object = FALSE) {
+ $request = $this->requestStack->getCurrentRequest();
+ foreach ($this->getSortedNegotiators() as $negotiator) {
+ if ($negotiator->applies($request)) {
+ if ($workspace_id = $negotiator->getWorkspaceId($request)) {
+ if ($object) {
+ return $this->entityTypeManager->getStorage('workspace')->load($workspace_id);
+ }
+ else {
+ return $workspace_id;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setActiveWorkspace(WorkspaceInterface $workspace) {
+ $default_workspace_id = \Drupal::getContainer()->getParameter('workspace.default');
+ // If the current user doesn't have access to view the workspace, they
+ // shouldn't be allowed to switch to it.
+ // @todo Could this be handled better?
+ if (!$workspace->access('view') && ($workspace->id() != $default_workspace_id)) {
+ $this->logger->error('Denied access to view workspace {workspace}', ['workspace' => $workspace->label()]);
+ throw new WorkspaceAccessException('The user does not have permission to view that workspace.');
+ }
+
+ // Set the workspace on the proper negotiator.
+ $request = $this->requestStack->getCurrentRequest();
+ foreach ($this->getSortedNegotiators() as $negotiator) {
+ if ($negotiator->applies($request)) {
+ $negotiator->persist($workspace);
+ break;
+ }
+ }
+
+ $supported_entity_types = $this->getSupportedEntityTypes();
+ foreach ($supported_entity_types as $supported_entity_type) {
+ $this->entityTypeManager->getStorage($supported_entity_type->id())->resetCache();
+ }
+
+ return $this;
+ }
+
+ /**
+ * @return \Drupal\workspace\Negotiator\WorkspaceNegotiatorInterface[]
+ */
+ protected function getSortedNegotiators() {
+ if (!isset($this->sortedNegotiators)) {
+ // Sort the negotiators according to priority.
+ krsort($this->negotiators);
+ // Merge nested negotiators from $this->negotiators into
+ // $this->sortedNegotiators.
+ $this->sortedNegotiators = [];
+ foreach ($this->negotiators as $builders) {
+ $this->sortedNegotiators = array_merge($this->sortedNegotiators, $builders);
+ }
+ }
+ return $this->sortedNegotiators;
+ }
+
+}
diff --git a/core/modules/workspace/src/WorkspaceManagerInterface.php b/core/modules/workspace/src/WorkspaceManagerInterface.php
new file mode 100644
index 0000000000..35ea690eb2
--- /dev/null
+++ b/core/modules/workspace/src/WorkspaceManagerInterface.php
@@ -0,0 +1,60 @@
+getParameter('renderer.config');
+ $renderer_config['required_cache_contexts'][] = 'workspace';
+ $container->setParameter('renderer.config', $renderer_config);
+ }
+
+}
diff --git a/core/modules/workspace/templates/workspace-toolbox.html.twig b/core/modules/workspace/templates/workspace-toolbox.html.twig
new file mode 100644
index 0000000000..24675a886d
--- /dev/null
+++ b/core/modules/workspace/templates/workspace-toolbox.html.twig
@@ -0,0 +1,24 @@
+{#
+/**
+ * @file
+ * Default theme implementation for the Workspace toolbox.
+ *
+ * @see template_preprocess_workspace_toolbox()
+ *
+ * @ingroup themeable
+ */
+#}
+
+
+
+ {% for workspace_form in workspace_forms %}
+
{{ workspace_form }}
+ {% endfor %}
+
+
+
+ {{ control_block }}
+ {{ deploy_form }}
+
+
+
\ No newline at end of file
diff --git a/core/modules/workspace/tests/src/Functional/ExistingContentTest.php b/core/modules/workspace/tests/src/Functional/ExistingContentTest.php
new file mode 100644
index 0000000000..e0be9b443a
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/ExistingContentTest.php
@@ -0,0 +1,96 @@
+createNodeType('Test', 'test');
+
+ $this->drupalLogin($this->rootUser);
+
+ $published_node = $this->createNodeThroughUI('Published node', 'test', TRUE);
+ $unpublished_node = $this->createNodeThroughUI('Unpublished node', 'test', FALSE);
+
+ $this->drupalLogout();
+
+ \Drupal::service('module_installer')->install(['workspace']);
+ $this->rebuildContainer();
+ $this->drupalLogin($this->rootUser);
+ $live = Workspace::load('live');
+ $stage = Workspace::load('stage');
+ $this->setupWorkspaceSwitcherBlock();
+
+ $this->assertNull($published_node->workspace->target_id);
+ $this->assertNull($unpublished_node->workspace->target_id);
+
+ $this->switchToWorkspace($stage);
+ $session = $this->assertSession();
+ $session->pageTextContains('Published node');
+ $session->pageTextNotContains('Unpublished node');
+
+ $this->drupalGet('/node/' . $published_node->id() . '/edit');
+ $session->pageTextContains('Published node');
+ $this->drupalPostForm(NULL, [
+ 'title[0][value]' => 'Published Stage node'
+ ], t('Save'));
+ $session->pageTextContains('Published stage node');
+
+ $this->drupalGet('/node/' . $unpublished_node->id() . '/edit');
+ $session->pageTextContains('Unpublished node');
+ $this->drupalPostForm(NULL, [
+ 'title[0][value]' => 'Published Unpublished Stage node',
+ 'status[value]' => TRUE,
+ ], t('Save'));
+ $session->pageTextContains('Published Unpublished stage node');
+
+ $this->drupalGet('');
+ $session->pageTextContains('Published Stage node');
+ $session->pageTextContains('Published Unpublished stage node');
+
+ $this->switchToWorkspace($live);
+ $session->pageTextContains('Published node');
+ $session->pageTextNotContains('Unpublished node');
+
+ /** @var \Drupal\workspace\Replication\ReplicationManager $replicator */
+ $replicator = \Drupal::service('workspace.replication_manager');
+ /** @var \Drupal\workspace\UpstreamManager $upstream */
+ $upstream = \Drupal::service('workspace.upstream_manager');
+ $replicator->replicate(
+ $upstream->createInstance('workspace:' . $stage->id()),
+ $upstream->createInstance('workspace:' . $live->id())
+ );
+
+ $this->drupalGet('');
+ $session->pageTextContains('Published Stage node');
+ $session->pageTextContains('Published Unpublished stage node');
+
+ $this->switchToWorkspace($stage);
+ $session->pageTextContains('Published Stage node');
+ $session->pageTextContains('Published Unpublished stage node');
+
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/ReplicationTest.php b/core/modules/workspace/tests/src/Functional/ReplicationTest.php
new file mode 100644
index 0000000000..fdf9e6f300
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/ReplicationTest.php
@@ -0,0 +1,119 @@
+createNodeType('Test', 'test');
+
+ $permissions = [
+ 'create workspace',
+ 'view any workspace',
+ 'create test content',
+ 'edit own test content',
+ 'access administration pages',
+ 'administer taxonomy',
+ 'administer menu',
+ 'access content overview',
+ 'administer content types',
+ 'administer node display',
+ 'administer node fields',
+ 'administer node form display',
+ 'administer workspaces',
+ ];
+ $test_user = $this->drupalCreateUser($permissions);
+ $this->drupalLogin($test_user);
+
+ $this->setupWorkspaceSwitcherBlock();
+ }
+
+ public function testNodeReplication() {
+ $dev = $this->createWorkspaceThroughUI('Dev', 'dev');
+ $stage = $this->getOneWorkspaceByLabel('Stage');
+ $live = $this->getOneWorkspaceByLabel('Live');
+ $this->switchToWorkspace($dev);
+
+ $this->drupalGet('/node/add/test');
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+ $page = $session->getPage();
+ $page->fillField('Title', 'Test node');
+ $page->findButton(t('Save'))->click();
+ $page = $session->getPage();
+ $this->assertTrue($page->hasContent("Test node has been created"));
+ $this->drupalGet('/node/1/edit');
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+ $page->findButton(t('Save'))->click();
+
+ $this->assertEquals($dev->id(), $this->getOneEntityByLabel('node', 'Test node')->workspace->target_id);
+
+ $this->drupalGet('/admin/structure/workspace/' . $dev->id() . '/deployment');
+ $session = $this->getSession();
+ $page = $session->getPage();
+ $this->assertEquals(200, $session->getStatusCode());
+ $this->assertTrue($page->hasContent('Update Dev from Stage or deploy to Stage.'));
+ $page->findButton('edit-deploy')->click();
+ $session->getPage()->hasContent('Successful deployment');
+
+ $this->switchToWorkspace($stage);
+ $this->assertEquals($stage->id(), $this->getOneEntityByLabel('node', 'Test node')->workspace->target_id);
+
+ $this->drupalGet('/node/add/test');
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+ $page = $session->getPage();
+ $page->fillField('Title', 'Test stage node');
+ $page->findButton(t('Save'))->click();
+ $page = $session->getPage();
+ $page->hasContent("Test stage node has been created");
+
+ $this->assertEquals($stage->id(), $this->getOneEntityByLabel('node', 'Test stage node')->workspace->target_id);
+
+ $this->drupalGet('/admin/structure/workspace/' . $stage->id() . '/deployment');
+ $session = $this->getSession();
+ $page = $session->getPage();
+ $this->assertEquals(200, $session->getStatusCode());
+ $this->assertTrue($page->hasContent('Update Stage from Live or deploy to Live.'));
+ $page->findButton('edit-deploy')->click();
+ $session->getPage()->hasContent('Successful deployment');
+
+ $this->switchToWorkspace($live);
+ $this->assertEquals($live->id(), $this->getOneEntityByLabel('node', 'Test node')->workspace->target_id);
+ $this->assertEquals($live->id(), $this->getOneEntityByLabel('node', 'Test stage node')->workspace->target_id);
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceBypassTest.php b/core/modules/workspace/tests/src/Functional/WorkspaceBypassTest.php
new file mode 100644
index 0000000000..e2b0dd92a1
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceBypassTest.php
@@ -0,0 +1,135 @@
+createNodeType('Test', 'test');
+ $this->setupWorkspaceSwitcherBlock();
+
+ $ditka = $this->drupalCreateUser(array_merge($permissions, ['create test content']));
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($ditka);
+
+ $vanilla_node = $this->createNodeThroughUI('Vanilla node', 'test');
+ $this->assertEquals('live', $vanilla_node->workspace->target_id);
+
+ $bears = $this->createWorkspaceThroughUI('Bears', 'bears');
+ $this->switchToWorkspace($bears);
+
+ // Now create a node in the Bears workspace, as the owner of that workspace.
+ $ditka_bears_node = $this->createNodeThroughUI('Ditka Bears node', 'test');
+ $this->assertEquals($bears->id(), $ditka_bears_node->workspace->entity->id());
+ $ditka_bears_node_id = $ditka_bears_node->id();
+
+ // Create a new user that should be able to edit anything in the Bears workspace.
+ $lombardi = $this->drupalCreateUser(array_merge($permissions, ['view_workspace_' . $bears->id(), 'bypass_entity_access_workspace_' . $bears->id()]));
+ $this->drupalLogin($lombardi);
+ $this->switchToWorkspace($bears);
+
+ // Because Lombardi has the bypass permission, he should be able to
+ // create and edit any node.
+
+ $this->drupalGet('/node/' . $ditka_bears_node_id . '/edit');
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+
+ $lombardi_bears_node = $this->createNodeThroughUI('Lombardi Bears node', 'test');
+ $this->assertEquals($bears->id(), $lombardi_bears_node->workspace->entity->id());
+ $lombardi_bears_node_id = $lombardi_bears_node->id();
+
+ $this->drupalLogin($ditka);
+ $this->switchToWorkspace($bears);
+
+ $this->drupalGet('/node/' . $lombardi_bears_node_id . '/edit');
+ $session = $this->getSession();
+ $this->assertEquals(403, $session->getStatusCode());
+
+ // Create a new user that should NOT be able to edit anything in the Bears workspace.
+ $belichick = $this->drupalCreateUser(array_merge($permissions, ['view_workspace_' . $bears->id()]));
+ $this->drupalLogin($belichick);
+ $this->switchToWorkspace($bears);
+
+ $this->drupalGet('/node/' . $ditka_bears_node_id . '/edit');
+ $session = $this->getSession();
+ $this->assertEquals(403, $session->getStatusCode());
+
+ }
+
+ /**
+ * Verifies that a user can edit anything in a workspace they own.
+ */
+ public function testBypassOwnWorkspace() {
+ $permissions = [
+ 'create workspace',
+ 'edit own workspace',
+ 'view own workspace',
+ 'bypass entity access own workspace',
+ ];
+
+ $this->createNodeType('Test', 'test');
+ $this->setupWorkspaceSwitcherBlock();
+
+ $ditka = $this->drupalCreateUser(array_merge($permissions, ['create test content']));
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($ditka);
+
+ $vanilla_node = $this->createNodeThroughUI('Vanilla node', 'test');
+ $this->assertEquals('live', $vanilla_node->workspace->target_id);
+
+ $bears = $this->createWorkspaceThroughUI('Bears', 'bears');
+ $this->switchToWorkspace($bears);
+
+ // Now create a node in the Bears workspace, as the owner of that workspace.
+ $ditka_bears_node = $this->createNodeThroughUI('Ditka Bears node', 'test');
+ $this->assertEquals($bears->id(), $ditka_bears_node->workspace->entity->id());
+ $ditka_bears_node_id = $ditka_bears_node->id();
+
+ // Editing both nodes should be possible.
+
+ $this->drupalGet('/node/' . $ditka_bears_node_id . '/edit');
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+
+ // Create a new user that should be able to edit anything in the Bears workspace.
+ $lombardi = $this->drupalCreateUser(array_merge($permissions, ['view_workspace_' . $bears->id()]));
+ $this->drupalLogin($lombardi);
+ $this->switchToWorkspace($bears);
+
+ // Because editor 2 has the bypass permission, he should be able to
+ // create and edit any node.
+
+ $this->drupalGet('/node/' . $ditka_bears_node_id . '/edit');
+ $session = $this->getSession();
+ $this->assertEquals(403, $session->getStatusCode());
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceEntityTest.php b/core/modules/workspace/tests/src/Functional/WorkspaceEntityTest.php
new file mode 100644
index 0000000000..09303f04ba
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceEntityTest.php
@@ -0,0 +1,157 @@
+createNodeType('Test', 'test');
+ $this->setupWorkspaceSwitcherBlock();
+
+ $buster = $this->drupalCreateUser(array_merge($permissions, ['view own unpublished content', 'create test content', 'edit own test content']));
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($buster);
+
+ $workspaces = [
+ 'live' => $this->getOneWorkspaceByLabel('Live'),
+ 'stage' => $this->getOneWorkspaceByLabel('Stage'),
+ 'dev' => $this->createWorkspaceThroughUI('Dev', 'dev'),
+ ];
+ $default = \Drupal::getContainer()->getParameter('workspace.default');
+ $this->switchToWorkspace($workspaces[$initial_workspace]);
+
+ $workspace_manager = \Drupal::service('workspace.manager');
+ $this->assertEquals($initial_workspace, $workspace_manager->getActiveWorkspace());
+
+ $vanilla_node = $this->createNodeThroughUI('Vanilla node', 'test');
+ $this->assertEquals($initial_workspace, $vanilla_node->workspace->target_id);
+
+ $this->drupalGet('/node');
+ $this->assertSession()->pageTextContains('Vanilla node');
+ $this->drupalGet('/node/' . $vanilla_node->id());
+ $this->assertSession()->pageTextContains('Vanilla node');
+
+ $strawberry_node = $this->createNodeThroughUI('Strawberry node', 'test', FALSE);
+ $this->assertEquals($initial_workspace, $strawberry_node->workspace->target_id);
+
+ $this->drupalGet('/node');
+ $this->assertSession()->pageTextNotContains('Strawberry node');
+ $this->drupalGet('/node/' . $strawberry_node->id());
+ $this->assertSession()->pageTextContains('Strawberry node');
+
+ $chocolate_node = $this->createNodeThroughUI('Chocolate node', 'test', FALSE);
+ $this->assertEquals($initial_workspace, $chocolate_node->workspace->target_id);
+
+ $this->drupalGet('/node');
+ $this->assertSession()->pageTextNotContains('Chocolate node');
+ $this->drupalGet('/node/' . $chocolate_node->id());
+ $this->assertSession()->pageTextContains('Chocolate node');
+
+ $this->drupalPostForm('/node/' . $chocolate_node->id() . '/edit', [
+ 'title[0][value]' => 'Mint node',
+ 'status[value]' => TRUE,
+ ], t('Save'));
+
+ $this->drupalGet('/node');
+ $this->assertSession()->pageTextContains('Mint node');
+ $this->drupalGet('/node/' . $chocolate_node->id());
+ $this->assertSession()->pageTextContains('Mint node');
+
+ foreach ($workspaces as $workspace_id => $workspace) {
+ if ($workspace_id != $initial_workspace) {
+ $this->switchToWorkspace($workspace);
+
+ if ($initial_workspace == $default || $workspace_id == $default) {
+ // When the node started on the default workspace, or the current
+ // workspace is default, entity queries should return the correct
+ // revision.
+ $node_list = \Drupal::entityTypeManager()
+ ->getStorage('node')
+ ->loadByProperties(['title' => $vanilla_node->label()]);
+ $this->assertSame($vanilla_node->getRevisionId(), reset($node_list)->getRevisionId());
+ }
+ else {
+ // When the node was created on a non-default workspace and the
+ // current workspace is not the default, entity queries should return
+ // nothing.
+ $node_list = \Drupal::entityTypeManager()
+ ->getStorage('node')
+ ->loadByProperties(['title' => $vanilla_node->label()]);
+ $this->assertSame(FALSE, reset($node_list));
+ }
+
+ // Entity load and load_multiple should always return the default
+ // revision.
+ $node_load = \Drupal::entityTypeManager()
+ ->getStorage('node')
+ ->load($vanilla_node->id());
+ $this->assertSame($vanilla_node->getRevisionId(), $node_load->getRevisionId());
+ $node = \Drupal::entityTypeManager()
+ ->getStorage('node')
+ ->loadUnchanged($vanilla_node->id());
+ $this->assertSame($vanilla_node->getRevisionId(), $node->getRevisionId());
+
+ if ($initial_workspace == $default) {
+ // Then the node was created on the default workspace it should
+ // appear via the UI on all other workspaces.
+ $this->drupalGet('/node');
+ $this->assertSession()->statusCodeEquals(200);
+ $this->assertSession()->pageTextContains('Vanilla node');
+ $this->drupalGet('/node/' . $vanilla_node->id());
+ $this->assertSession()->statusCodeEquals(200);
+ $this->assertSession()->pageTextContains('Vanilla node');
+ }
+ else {
+ // When the node was not created on the default it should only not
+ // appear via the UI.
+ $this->drupalGet('/node');
+ $this->assertSession()->statusCodeEquals(200);
+ $this->assertSession()->pageTextNotContains('Vanilla node');
+ $this->drupalGet('/node/' . $vanilla_node->id());
+ $this->assertSession()->statusCodeEquals(403);
+ $this->assertSession()->pageTextNotContains('Vanilla node');
+ }
+ }
+ }
+ }
+
+ public function nodeEntityTestCases() {
+ return [
+ ['live'],
+ ['stage'],
+ ['dev'],
+ ];
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceIndividualPermissionsTest.php b/core/modules/workspace/tests/src/Functional/WorkspaceIndividualPermissionsTest.php
new file mode 100644
index 0000000000..33f692c73f
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceIndividualPermissionsTest.php
@@ -0,0 +1,99 @@
+drupalCreateUser($permissions);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor1);
+
+ $this->createWorkspaceThroughUI('Bears', 'bears');
+ $bears = $this->getOneWorkspaceByLabel('Bears');
+
+ // Now login as a different user with permission to edit that workspace,
+ // specifically.
+
+ $editor2 = $this->drupalCreateUser(array_merge($permissions, ['update_workspace_' . $bears->id()]));
+
+ $this->drupalLogin($editor2);
+ $session = $this->getSession();
+
+ $this->drupalGet("/admin/structure/workspace/{$bears->id()}/edit");
+ $this->assertEquals(200, $session->getStatusCode());
+ }
+
+ /**
+ * Verifies that a user can view a specific workspace.
+ */
+ public function testViewIndividualWorkspace() {
+ $permissions = [
+ 'access administration pages',
+ 'administer site configuration',
+ 'create workspace',
+ 'edit own workspace',
+ ];
+
+ $editor1 = $this->drupalCreateUser($permissions);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor1);
+
+ $this->createWorkspaceThroughUI('Bears', 'bears');
+ $bears = $this->getOneWorkspaceByLabel('Bears');
+
+ // Now login as a different user and create a workspace.
+
+ $editor2 = $this->drupalCreateUser(array_merge($permissions, ['view_workspace_' . $bears->id()]));
+
+ $this->drupalLogin($editor2);
+ $session = $this->getSession();
+
+ $this->createWorkspaceThroughUI('Packers', 'packers');
+
+ $packers = $this->getOneWorkspaceByLabel('Packers');
+
+ // Load the activate form for the Bears workspace. It should work, because
+ // the user has the permission specific to that workspace.
+ $this->drupalGet("admin/structure/workspace/{$bears->id()}/activate");
+ $this->assertEquals(200, $session->getStatusCode());
+
+ // But editor 1 cannot view the Packers workspace.
+
+ $this->drupalLogin($editor1);
+ $this->drupalGet("admin/structure/workspace/{$packers->id()}/activate");
+ $this->assertEquals(403, $session->getStatusCode());
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspacePermissionsTest.php b/core/modules/workspace/tests/src/Functional/WorkspacePermissionsTest.php
new file mode 100644
index 0000000000..dce008d121
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspacePermissionsTest.php
@@ -0,0 +1,168 @@
+drupalCreateUser([
+ 'access administration pages',
+ 'administer site configuration',
+ 'create workspace',
+ ]);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor);
+ $session = $this->getSession();
+
+ $this->drupalGet('/admin/structure/workspace/add');
+
+ $this->assertEquals(200, $session->getStatusCode());
+
+ $page = $session->getPage();
+ $page->fillField('label', 'Bears');
+ $page->fillField('id', 'bears');
+ $page->findButton(t('Save'))->click();
+
+ $session->getPage()->hasContent('Bears (bears)');
+
+ // Now edit that same workspace; We shouldn't be able to do so, since
+ // we don't have edit permissions.
+
+ /** @var \Drupal\Core\Entity\EntityTypeManagerInterface $etm */
+ $etm = \Drupal::service('entity_type.manager');
+ /** @var \Drupal\workspace\Entity\WorkspaceInterface $bears */
+ $entity_list = $etm->getStorage('workspace')->loadByProperties(['label' => 'Bears']);
+ $bears = current($entity_list);
+
+ $this->drupalGet("/admin/structure/workspace/{$bears->id()}/edit");
+ $this->assertEquals(403, $session->getStatusCode());
+
+ // @todo add Deletion checks once there's a UI for deletion.
+ }
+
+ /**
+ * Verifies that a user can create and edit only their own workspace.
+ */
+ public function testEditOwnWorkspace() {
+ $permissions = [
+ 'access administration pages',
+ 'administer site configuration',
+ 'create workspace',
+ 'edit own workspace',
+ ];
+
+ $editor1 = $this->drupalCreateUser($permissions);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor1);
+
+ $this->createWorkspaceThroughUI('Bears', 'bears');
+
+ // Now edit that same workspace; We should be able to do so.
+
+ $bears = $this->getOneWorkspaceByLabel('Bears');
+
+ $session = $this->getSession();
+
+ $this->drupalGet("/admin/structure/workspace/{$bears->id()}/edit");
+ $this->assertEquals(200, $session->getStatusCode());
+
+ $page = $session->getPage();
+ $page->fillField('label', 'Bears again');
+ $page->fillField('id', 'bears');
+ $page->findButton(t('Save'))->click();
+ $session->getPage()->hasContent('Bears again (bears)');
+
+ // Now login as a different user and ensure they don't have edit access,
+ // and vice versa.
+
+ $editor2 = $this->drupalCreateUser($permissions);
+
+ $this->drupalLogin($editor2);
+ $session = $this->getSession();
+
+ $this->createWorkspaceThroughUI('Packers', 'packers');
+
+ $packers = $this->getOneWorkspaceByLabel('Packers');
+
+ $this->drupalGet("/admin/structure/workspace/{$packers->id()}/edit");
+ $this->assertEquals(200, $session->getStatusCode());
+
+ $this->drupalGet("/admin/structure/workspace/{$bears->id()}/edit");
+ $this->assertEquals(403, $session->getStatusCode());
+ }
+
+ /**
+ * Verifies that a user can edit any workspace.
+ */
+ public function testEditAnyWorkspace() {
+ $permissions = [
+ 'access administration pages',
+ 'administer site configuration',
+ 'create workspace',
+ 'edit own workspace',
+ ];
+
+ $editor1 = $this->drupalCreateUser($permissions);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor1);
+
+ $this->createWorkspaceThroughUI('Bears', 'bears');
+
+ // Now edit that same workspace; We should be able to do so.
+
+ $bears = $this->getOneWorkspaceByLabel('Bears');
+
+ $session = $this->getSession();
+
+ $this->drupalGet("/admin/structure/workspace/{$bears->id()}/edit");
+ $this->assertEquals(200, $session->getStatusCode());
+
+ $page = $session->getPage();
+ $page->fillField('label', 'Bears again');
+ $page->fillField('id', 'bears');
+ $page->findButton(t('Save'))->click();
+ $session->getPage()->hasContent('Bears again (bears)');
+
+ // Now login as a different user and ensure they don't have edit access,
+ // and vice versa.
+
+ $admin = $this->drupalCreateUser(array_merge($permissions, ['edit any workspace']));
+
+ $this->drupalLogin($admin);
+ $session = $this->getSession();
+
+ $this->createWorkspaceThroughUI('Packers', 'packers');
+
+ $packers = $this->getOneWorkspaceByLabel('Packers');
+
+ $this->drupalGet("/admin/structure/workspace/{$packers->id()}/edit");
+ $this->assertEquals(200, $session->getStatusCode());
+
+ $this->drupalGet("/admin/structure/workspace/{$bears->id()}/edit");
+ $this->assertEquals(200, $session->getStatusCode());
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceSwitcherTest.php b/core/modules/workspace/tests/src/Functional/WorkspaceSwitcherTest.php
new file mode 100644
index 0000000000..cc76c731b1
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceSwitcherTest.php
@@ -0,0 +1,53 @@
+setupWorkspaceSwitcherBlock();
+
+ $mayer = $this->drupalCreateUser($permissions);
+ $this->drupalLogin($mayer);
+
+ $vultures = $this->createWorkspaceThroughUI('Vultures', 'vultures');
+ $this->switchToWorkspace($vultures);
+
+ $gravity = $this->createWorkspaceThroughUI('Gravity', 'gravity');
+
+ $this->drupalGet('/admin/structure/workspace/' . $gravity->id() . '/activate');
+
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+ $page = $session->getPage();
+ $page->findButton(t('Activate'))->click();
+
+ $session->getPage()->findLink($gravity->label());
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceTest.php b/core/modules/workspace/tests/src/Functional/WorkspaceTest.php
new file mode 100644
index 0000000000..50d7a9ef95
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceTest.php
@@ -0,0 +1,42 @@
+drupalCreateUser($permissions);
+ $this->drupalLogin($editor1);
+
+ // Test a valid workspace name
+ $this->createWorkspaceThroughUI('Workspace 1', 'a0_$()+-/');
+
+ // Test and invaid workspace name
+ $this->drupalGet('/admin/structure/workspace/add');
+ $session = $this->getSession();
+ $this->assertEquals(200, $session->getStatusCode());
+ $page = $session->getPage();
+ $page->fillField('label', 'workspace2');
+ $page->fillField('id', 'A!"£%^&*{}#~@?');
+ $page->findButton(t('Save'))->click();
+ $session->getPage()->hasContent("This value is not valid");
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceTestUtilities.php b/core/modules/workspace/tests/src/Functional/WorkspaceTestUtilities.php
new file mode 100644
index 0000000000..1b0b2e96d2
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceTestUtilities.php
@@ -0,0 +1,217 @@
+getOneEntityByLabel('workspace', $label);
+ }
+
+ /**
+ * Loads a single entity by its label.
+ *
+ * The UI approach to creating an entity doesn't make it easy to know what
+ * the ID is, so this lets us make paths for an entity after it's created.
+ *
+ * @param string $type
+ * The type of entity to load.
+ * @param $label
+ * The label of the entity to load.
+ * @return \Drupal\workspace\Entity\WorkspaceInterface
+ */
+ protected function getOneEntityByLabel($type, $label) {
+ /** @var \Drupal\Core\Entity\EntityTypeManagerInterface $etm */
+ $etm = \Drupal::service('entity_type.manager');
+
+ $property = $etm->getDefinition($type)->getKey('label');
+
+ $entity_list = $etm->getStorage($type)->loadByProperties([$property => $label]);
+
+ $entity = current($entity_list);
+
+ if (!$entity) {
+ $this->fail("No {$type} entity named {$label} found.");
+ }
+
+ return $entity;
+ }
+
+ /**
+ * Creates a new Workspace through the UI.
+ *
+ * @param string $label
+ * The label of the workspace to create.
+ * @param string $id
+ * The ID of the workspace to create.
+ *
+ * @return \Drupal\workspace\Entity\WorkspaceInterface
+ * The workspace that was just created.
+ *
+ * @throws \Behat\Mink\Exception\ElementNotFoundException
+ */
+ protected function createWorkspaceThroughUI($label, $id) {
+ $this->drupalGet('/admin/structure/workspace/add');
+
+ $session = $this->getSession();
+ $this->assertSession()->statusCodeEquals(200);
+
+ /** @var \Behat\Mink\Element\DocumentElement $page */
+ $page = $session->getPage();
+ $page->fillField('label', $label);
+ $page->fillField('id', $id);
+ if ($id == 'dev') {
+ $page->selectFieldOption('upstream', 'workspace:stage');
+ }
+ $page->findButton(t('Save'))->click();
+
+ $session->getPage()->hasContent("$label ($id)");
+
+ return $this->getOneWorkspaceByLabel($label);
+ }
+
+ /**
+ * Adds the workspace switcher block to the site.
+ *
+ * This is necessary for switchToWorkspace() to function correctly.
+ */
+ protected function setupWorkspaceSwitcherBlock() {
+ // Add the block to the sidebar.
+ $this->drupalPlaceBlock('workspace_switcher_block', [
+ 'id' => 'workspaceswitcher',
+ 'region' => 'sidebar_first',
+ 'label' => 'Workspace switcher',
+ ]);
+
+ // Confirm the block shows on the front page.
+ $this->drupalGet('');
+ $page = $this->getSession()->getPage();
+
+ $this->assertTrue($page->hasContent('Workspace switcher'));
+ }
+
+ /**
+ * Sets a given workspace as "active" for subsequent requests.
+ *
+ * This assumes that the switcher block has already been setup by calling
+ * setupWorkspaceSwitcherBlock().
+ *
+ * @param \Drupal\workspace\Entity\WorkspaceInterface $workspace
+ * The workspace to set active.
+ */
+ protected function switchToWorkspace(WorkspaceInterface $workspace) {
+ // Switch the test runner's context to the specified workspace.
+ \Drupal::service('workspace.manager')->setActiveWorkspace($workspace);
+
+ // Switch the system under test to the specified workspace.
+ $this->getSession()->getPage()->findButton($workspace->label())->click();
+
+ // If we don't do both of those, test runner utility methods will not be
+ // run in the same workspace as the system under test, and you'll be left
+ // wondering why your test runner cannot find content you just created.
+ }
+
+ /**
+ * Creates a new node type.
+ *
+ * @param string $label
+ * The human-readable label of the type to create.
+ * @param string $machine_name
+ * The machine name of the type to create.
+ */
+ protected function createNodeType($label, $machine_name) {
+ $node_type = NodeType::create([
+ 'type' => $machine_name,
+ 'label' => $label,
+ ]);
+ $node_type->save();
+ }
+
+
+ /**
+ * Creates a node by "clicking" buttons.
+ *
+ * @param string $label
+ * @param string $bundle
+ * @param bool $publish
+ *
+ * @return \Drupal\workspace\Entity\WorkspaceInterface
+ *
+ * @throws \Behat\Mink\Exception\ElementNotFoundException
+ */
+ protected function createNodeThroughUI($label, $bundle, $publish = TRUE) {
+ $this->drupalGet('/node/add/' . $bundle);
+
+ /** @var \Behat\Mink\Session $session */
+ $session = $this->getSession();
+ $this->assertSession()->statusCodeEquals(200);
+
+ /** @var \Behat\Mink\Element\DocumentElement $page */
+ $page = $session->getPage();
+ $page->fillField('Title', $label);
+ if ($publish) {
+ $page->findButton(t('Save'))->click();
+ }
+ else {
+ $page->uncheckField('Published');
+ $page->findButton(t('Save'))->click();
+ }
+
+ $session->getPage()->hasContent("{$label} has been created");
+
+ return $this->getOneEntityByLabel('node', $label);
+ }
+
+ /**
+ * Returns a pointer to the specified workspace.
+ *
+ * @todo Replace this with a common method in the module somewhere.
+ *
+ * @param \Drupal\workspace\Entity\WorkspaceInterface $workspace
+ * The workspace for which we want a pointer.
+ * @return \Drupal\workspace\WorkspacePointerInterface
+ * The pointer to the provided workspace.
+ */
+ protected function getPointerToWorkspace(WorkspaceInterface $workspace) {
+ /** @var \Drupal\Core\Entity\EntityTypeManagerInterface $etm */
+ $etm = \Drupal::service('entity_type.manager');
+
+ $pointers = $etm->getStorage('workspace_pointer')
+ ->loadByProperties(['workspace_pointer' => $workspace->id()]);
+ $pointer = reset($pointers);
+ return $pointer;
+ }
+
+ /**
+ * Determine if the content list has an entity's label.
+ *
+ * This assertion can be used to validate a particular entity exists in the
+ * current workspace.
+ */
+ protected function isLabelInContentOverview($label) {
+ $this->drupalGet('/admin/content');
+ $session = $this->getSession();
+ $this->assertSession()->statusCodeEquals(200);
+ $page = $session->getPage();
+ return $page->hasContent($label);
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Functional/WorkspaceViewTest.php b/core/modules/workspace/tests/src/Functional/WorkspaceViewTest.php
new file mode 100644
index 0000000000..b3aa981fa0
--- /dev/null
+++ b/core/modules/workspace/tests/src/Functional/WorkspaceViewTest.php
@@ -0,0 +1,104 @@
+drupalCreateUser($permissions);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor1);
+
+ $this->createWorkspaceThroughUI('Bears', 'bears');
+
+ $bears = $this->getOneWorkspaceByLabel('Bears');
+
+ // Now login as a different user and create a workspace.
+
+ $editor2 = $this->drupalCreateUser($permissions);
+
+ $this->drupalLogin($editor2);
+ $session = $this->getSession();
+
+ $this->createWorkspaceThroughUI('Packers', 'packers');
+
+ $packers = $this->getOneWorkspaceByLabel('Packers');
+
+ // Load the activate form for the Bears workspace. It should fail because
+ // the workspace belongs to someone else.
+ $this->drupalGet("admin/structure/workspace/{$bears->id()}/activate");
+ $this->assertEquals(403, $session->getStatusCode());
+
+ // But editor 2 should be able to activate the Packers workspace.
+ $this->drupalGet("admin/structure/workspace/{$packers->id()}/activate");
+ $this->assertEquals(200, $session->getStatusCode());
+ }
+
+ /**
+ * Verifies that a user can view any workspace.
+ */
+ public function testViewAnyWorkspace() {
+ $permissions = [
+ 'access administration pages',
+ 'administer site configuration',
+ 'create workspace',
+ 'edit own workspace',
+ 'view any workspace',
+ ];
+
+ $editor1 = $this->drupalCreateUser($permissions);
+
+ // Login as a limited-access user and create a workspace.
+ $this->drupalLogin($editor1);
+
+ $this->createWorkspaceThroughUI('Bears', 'bears');
+
+ $bears = $this->getOneWorkspaceByLabel('Bears');
+
+ // Now login as a different user and create a workspace.
+
+ $editor2 = $this->drupalCreateUser($permissions);
+
+ $this->drupalLogin($editor2);
+ $session = $this->getSession();
+
+ $this->createWorkspaceThroughUI('Packers', 'packers');
+
+ $packers = $this->getOneWorkspaceByLabel('Packers');
+
+ // Load the activate form for the Bears workspace. This user should be
+ // able to see both workspaces because of the "view any" permission.
+ $this->drupalGet("admin/structure/workspace/{$bears->id()}/activate");
+ $this->assertEquals(200, $session->getStatusCode());
+
+ // But editor 2 should be able to activate the Packers workspace.
+ $this->drupalGet("admin/structure/workspace/{$packers->id()}/activate");
+ $this->assertEquals(200, $session->getStatusCode());
+ }
+
+}
diff --git a/core/modules/workspace/tests/src/Kernel/DatabaseStorageSortedSetTest.php b/core/modules/workspace/tests/src/Kernel/DatabaseStorageSortedSetTest.php
new file mode 100644
index 0000000000..871491c42f
--- /dev/null
+++ b/core/modules/workspace/tests/src/Kernel/DatabaseStorageSortedSetTest.php
@@ -0,0 +1,143 @@
+collection = $this->randomMachineName();
+ $this->serializer = \Drupal::service('serialization.phpserialize');
+ $this->connection = \Drupal::service('database');
+ $this->store = \Drupal::service('workspace.keyvalue.sorted_set')->get($this->collection);
+ }
+
+ /**
+ * Helper method to assert key value pairs.
+ *
+ * @param $expected_pairs array
+ * Array of expected key value pairs.
+ */
+ public function assertPairs(array $expected_pairs) {
+ $result = $this->connection->select('key_value_sorted', 't')
+ ->fields('t', ['name', 'value'])
+ ->condition('collection', $this->collection)
+ ->condition('name', array_keys($expected_pairs), 'IN')
+ ->execute()
+ ->fetchAllAssoc('name');
+
+ $expected_count = count($expected_pairs);
+ $this->assertCount($expected_count, $result, "Query affected $expected_count records.");
+ foreach ($expected_pairs as $key => $value) {
+ $this->assertSame($value, $this->serializer->decode($result[$key]->value), "Key $key have value $value");
+ }
+ }
+
+ /**
+ * Helper method to assert the number of records.
+ *
+ * @param $expected int
+ * Expected number of records.
+ * @param $message string
+ * The message to display.
+ */
+ public function assertRecords($expected, $message = NULL) {
+ $count = $this->store->getCount();
+ $this->assertEquals($expected, $count, $message ? $message : "There are $expected records.");
+ }
+
+ /**
+ * Helper method to generate a key based on microtime().
+ *
+ * @return int
+ * A key based on microtime().
+ */
+ public function newKey() {
+ return (int) (microtime(TRUE) * 1000000);
+ }
+
+ /**
+ * Tests getting and setting of sorted key value sets.
+ */
+ public function testCalls() {
+ $key0 = $this->newKey();
+ $value0 = $this->randomMachineName();
+ $this->store->add($key0, $value0);
+ $this->assertPairs([$key0 => $value0]);
+
+ $key1 = $this->newKey();
+ $value1 = $this->randomMachineName();
+ $this->store->add($key1, $value1);
+ $this->assertPairs([$key1 => $value1]);
+
+ // Ensure it works to add sets with the same key.
+ $key2 = $this->newKey();
+ $value2 = $this->randomMachineName();
+ $value3 = $this->randomMachineName();
+ $value4 = $this->randomMachineName();
+ $this->store->addMultiple([
+ [$key2 => $value2],
+ [$key2 => $value3],
+ [$key2 => $value4],
+ ]);
+
+ $this->assertRecords(5, 'Correct number of records in the collection.');
+
+ $value = $this->store->getRange($key1, $key2);
+ $this->assertSame([$value1, $value2, $value3, $value4], $value);
+
+ $value = $this->store->getRange($key1);
+ $this->assertSame([$value1, $value2, $value3, $value4], $value);
+
+ $new1 = $this->newKey();
+ $this->store->add($new1, $value1);
+
+ $value = $this->store->getRange($new1, $new1);
+ $this->assertSame([$value1], $value, 'Value was successfully updated.');
+ $this->assertRecords(5, 'Correct number of records in the collection after value update.');
+
+ $value = $this->store->getRange($key1, $key1);
+ $this->assertSame([], $value, 'Non-existing range returned empty array.');
+
+ $max_key = $this->store->getMaxKey();
+ $this->assertEquals($new1, $max_key, 'The getMaxKey method returned correct key.');
+
+ $min_key = $this->store->getMinKey();
+ $this->assertEquals($key0, $min_key, 'The getMinKey method returned correct key.');
+ }
+
+}
diff --git a/core/modules/workspace/workspace.info.yml b/core/modules/workspace/workspace.info.yml
new file mode 100644
index 0000000000..ec543d1d15
--- /dev/null
+++ b/core/modules/workspace/workspace.info.yml
@@ -0,0 +1,9 @@
+name: Workspace
+type: module
+description: 'Provides the ability to have multiple workspaces on a single site to facilitate things like full-site preview and content staging.'
+version: VERSION
+core: 8.x
+package: Core (Experimental)
+dependencies:
+ - user
+ - serialization
diff --git a/core/modules/workspace/workspace.install b/core/modules/workspace/workspace.install
new file mode 100644
index 0000000000..6ed94d839d
--- /dev/null
+++ b/core/modules/workspace/workspace.install
@@ -0,0 +1,22 @@
+ 'live', 'label' => 'Live']);
+ $live->save();
+
+ /** @var \Drupal\workspace\Entity\WorkspaceInterface $stage */
+ $stage = Workspace::create(['id' => 'stage', 'label' => 'Stage']);
+ $stage->set('upstream', 'workspace:' . $live->id());
+ $stage->save();
+}
diff --git a/core/modules/workspace/workspace.libraries.yml b/core/modules/workspace/workspace.libraries.yml
new file mode 100644
index 0000000000..f38ed90503
--- /dev/null
+++ b/core/modules/workspace/workspace.libraries.yml
@@ -0,0 +1,28 @@
+drupal.workspace.toolbar:
+ version: VERSION
+ css:
+ theme:
+ css/workspace.toolbar.css: {}
+
+drupal.workspace.admin:
+ version: VERSION
+ css:
+ theme:
+ css/workspace.admin.css: {}
+
+drupal.workspace.switcher:
+ version: VERSION
+ css:
+ theme:
+ css/workspace.switcher.css: {}
+
+drupal.workspace.toolbox:
+ version: VERSION
+ css:
+ component:
+ css/workspace.toolbox.css: {}
+ js:
+ js/workspace.toolbox.js: {}
+ dependencies:
+ - core/jquery
+ - core/drupal
diff --git a/core/modules/workspace/workspace.links.action.yml b/core/modules/workspace/workspace.links.action.yml
new file mode 100644
index 0000000000..9f22598f30
--- /dev/null
+++ b/core/modules/workspace/workspace.links.action.yml
@@ -0,0 +1,5 @@
+entity.workspace.add_form:
+ route_name: entity.workspace.add_form
+ title: 'Add workspace'
+ appears_on:
+ - entity.workspace.collection
diff --git a/core/modules/workspace/workspace.links.menu.yml b/core/modules/workspace/workspace.links.menu.yml
new file mode 100644
index 0000000000..fc925cfa2d
--- /dev/null
+++ b/core/modules/workspace/workspace.links.menu.yml
@@ -0,0 +1,5 @@
+entity.workspace.collection:
+ title: 'Workspaces'
+ parent: system.admin_structure
+ description: 'Create and manage workspaces.'
+ route_name: entity.workspace.collection
diff --git a/core/modules/workspace/workspace.module b/core/modules/workspace/workspace.module
new file mode 100644
index 0000000000..60c50a1b9b
--- /dev/null
+++ b/core/modules/workspace/workspace.module
@@ -0,0 +1,358 @@
+' . t('About') . '';
+ $output .= '
' . t('The Workspace module allows workspaces to be defined and switched between. Content is then assigned to the active workspace when created. For more information, see the online documentation for the Workspace module.', [':workspace' => 'https://www.drupal.org/node/2824024']) . '