<p>
The WorkSpace to rebuild. You can specify a single WorkSpace.
</p>

@param rebuildWorkspaceRequests
The WorkSpace to rebuild. You can specify a single WorkSpace.
973662
public void setRebuildWorkspaceRequests(java.util.Collection<RebuildRequest> rebuildWorkspaceRequests) {
        if (rebuildWorkspaceRequests == null) {
            this.rebuildWorkspaceRequests = null;
            return;
        }

        this.rebuildWorkspaceRequests = new com.amazonaws.internal.SdkInternalList<RebuildRequest>(rebuildWorkspaceRequests);
    }
621981
public void write(Workspace workspace) {
        StringWriter stringWriter = new StringWriter();
        write(workspace, stringWriter);
        System.out.println(stringWriter.toString());
    }
790291
public void setBuildWorkspaceReader(List<Artifact> artifacts) {
        BuildWorkspaceReader reader = new BuildWorkspaceReader();
        
        for ( Artifact artifact : artifacts ) {
            reader.addArtifact( artifact );
        }
        
        systemSession = (MavenRepositorySystemSession)systemSession.setWorkspaceReader( reader );
        
    }
907155
@Override
	public void serviceRequest(final Request request) {
		// Get window id off the request
		windowId = request.getParameter(WWindow.WWINDOW_REQUEST_PARAM_KEY);

		if (windowId == null) {
			super.serviceRequest(request);
		} else {
			// Get the window component
			ComponentWithContext target = WebUtilities.getComponentById(windowId, true);
			if (target == null) {
				throw new SystemException("No window component for id " + windowId);
			}

			// Setup the Environment on the context
			UIContext uic = UIContextHolder.getCurrentPrimaryUIContext();
			Environment originalEnvironment = uic.getEnvironment();
			uic.setEnvironment(new EnvironmentDelegate(originalEnvironment, windowId, target));

			if (attachWindow) {
				attachUI(target.getComponent());
			}
			UIContextHolder.pushContext(target.getContext());
			try {
				super.serviceRequest(request);
			} finally {
				uic.setEnvironment(originalEnvironment);
				UIContextHolder.popContext();
			}
		}
	}
778090
private void initWorkspace(WorkspaceEntry wsConfig) throws RepositoryException
   {

      WorkspaceContainer workspaceContainer = getWorkspaceContainer(wsConfig.getName());

      // touch independent components
      workspaceContainer.getComponentInstanceOfType(IdGenerator.class);

      // Init Root and jcr:system if workspace is system workspace
      WorkspaceInitializer wsInitializer =
         (WorkspaceInitializer)workspaceContainer.getComponentInstanceOfType(WorkspaceInitializer.class);
      RepositoryCreationSynchronizer synchronizer =
         (RepositoryCreationSynchronizer)getComponentInstanceOfType(RepositoryCreationSynchronizer.class);
      // The synchronizer will be used to synchronize all the cluster
      // nodes to prevent any concurrent jcr initialization i.e. EXOJCR-887
      synchronizer.waitForApproval(wsInitializer.isWorkspaceInitialized());

      SystemParametersPersistenceConfigurator sppc =
         (SystemParametersPersistenceConfigurator)parent
            .getComponentInstanceOfType(SystemParametersPersistenceConfigurator.class);

      if (sppc != null)
      {
         setInitializerAndValidateOverriddenParameters(wsConfig, wsInitializer);
      }

      wsInitializer.initWorkspace();
   }
185970
@RequestMapping(value = "/spaces/snapshots/{storeId}/{snapshotId}/restore-space-id", method = RequestMethod.GET)
    @ResponseBody
    public String restoreSpaceId(HttpServletRequest request,
                                 @PathVariable("storeId") String storeId,
                                 @PathVariable("snapshotId") String snapshotId) throws Exception {
        ContentStore contentStore = getContentStore(storeId);

        String spaceId = SnapshotIdentifier.parseSnapshotId(snapshotId).getRestoreSpaceId();

        if (contentStore.spaceExists(spaceId)) {
            return "{ \"spaceId\": \"" + spaceId + "\"," + "\"storeId\": \"" + storeId + "\"}";
        } else {
            return "{}";
        }
    }
578732
public void deleteNamespace(String namespaceId) {

        DeleteNamespaceRequest deleteNamespaceRequest = new DeleteNamespaceRequest().withId(namespaceId);
        getDiscoveryClient().deleteNamespace(deleteNamespaceRequest);

    }
1142933
@Override
    public void actionCommit() {

        List<Throwable> errors = new ArrayList<Throwable>();

        try {
            // forward to the rebuild report page
            Map<String, String[]> params = new HashMap<String, String[]>();
            // rebuild report built for several indexes (comma-separated value string)
            params.put(CmsRebuildReport.PARAM_INDEXES, new String[] {getSearchIndexIndex().getName()});
            params.put(PARAM_STYLE, new String[] {CmsToolDialog.STYLE_NEW});
            getToolManager().jspForwardTool(this, "/searchindex/singleindex/rebuildreport", params);

        } catch (Throwable t) {
            errors.add(t);
        }
        // set the list of errors to display when saving failed
        setCommitErrors(errors);
    }
1000391
public void internalRemoveWorkspace(final String workspaceName) throws RepositoryException
   {
      SecurityHelper.validateSecurityPermission(JCRRuntimePermissions.MANAGE_REPOSITORY_PERMISSION);

      final WorkspaceContainer workspaceContainer = repositoryContainer.getWorkspaceContainer(workspaceName);
      try
      {
         SecurityHelper.doPrivilegedAction(new PrivilegedAction<Void>()
         {
            public Void run()
            {
               workspaceContainer.stop();
               return null;
            }
         });
      }
      catch (Exception e)
      {
         throw new RepositoryException(e);
      }
      SecurityHelper.doPrivilegedAction(new PrivilegedAction<Void>()
      {
         public Void run()
         {
            repositoryContainer.unregisterComponent(workspaceName);
            return null;
         }
      });

      config.getWorkspaceEntries().remove(repositoryContainer.getWorkspaceEntry(workspaceName));

      for (WorkspaceManagingListener listener : workspaceListeners)
      {
         listener.onWorkspaceRemove(workspaceName);
      }
   }
1363228
@Override
    public void destroyWorkspace() {
        ensureThreadExistense();

        MemoryWorkspace workspace = backingMap.get().get(MemoryWorkspace.DEFAULT_ID);
        //if (workspace != null)
        //workspace.destroyWorkspace();

        backingMap.get().remove(MemoryWorkspace.DEFAULT_ID);
    }
1279311
public Future<Boolean> reindexContentAsync( final JcrWorkspace workspace ) {
        return indexingExecutorService.submit(() -> {
            reindexContent(workspace);
            return Boolean.TRUE;
        });
    }
174067
private String composeWorkspaceUniqueName(String repositoryName, String workspaceName)
   {
      StringBuilder builder = new StringBuilder();
      builder.append(repositoryName);
      builder.append('/');
      builder.append(workspaceName);
      builder.append('/');

      return builder.toString();
   }
849724
@Override
    public void afterProjectsRead(final MavenSession session) throws MavenExecutionException {
        boolean anyProject = false;
        for (MavenProject project : session.getProjects()) {
            if (project.getPlugin("ceylon") != null
            	|| project.getPlugin("ceylon-maven-plugin") != null
            	|| "ceylon".equals(project.getArtifact().getArtifactHandler().getPackaging())
                || "car".equals(project.getArtifact().getArtifactHandler().getPackaging())
                || "ceylon-jar".equals(project.getArtifact().getArtifactHandler().getPackaging())
                || usesCeylonRepo(project)) {
            	anyProject = true;
            }
        }
        if (anyProject) {
        	logger.info("At least one project is using the Ceylon plugin. Preparing.");
        	findCeylonRepo(session);
        }
        logger.info("Adding Ceylon repositories to build");
        session.getRequest().setWorkspaceReader(
        		new CeylonWorkspaceReader(
        				session.getRequest().getWorkspaceReader(),
        				logger));
    }
721072
public void rebuild(StaplerRequest req, JSONObject json, List<? extends Descriptor<T>> descriptors) throws FormException, IOException {
        List<T> newList = new ArrayList<>();

        for (Descriptor<T> d : descriptors) {
            T existing = get((D)d);
            String name = d.getJsonSafeClassName();
            JSONObject o = json.optJSONObject(name);

            T instance = null;
            if (o!=null) {
                if (existing instanceof ReconfigurableDescribable)
                    instance = (T)((ReconfigurableDescribable)existing).reconfigure(req,o);
                else
                    instance = d.newInstance(req, o);
            } else {
                if (existing instanceof ReconfigurableDescribable)
                    instance = (T)((ReconfigurableDescribable)existing).reconfigure(req,null);
            }

            if (instance!=null)
                newList.add(instance);
        }

        replaceBy(newList);
    }
804038
function workspacesUrl(workspaceSid) {
  return _.join(
    _.filter([TASKROUTER_BASE_URL, TASKROUTER_VERSION, 'Workspaces', workspaceSid], _.isString),
    '/'
  );
}
184621
protected CachedNode nodeInWorkspace( AbstractSessionCache session ) {
        return isNew() ? null : session.getWorkspace().getNode(key);
    }
567089
protected void restoreWorkspace() throws Throwable
   {
      boolean restored = true;
      RepositoryImpl repository = (RepositoryImpl)repositoryService.getRepository(repositoryName);
      try
      {
         RepositoryEntry reEntry = repository.getConfiguration();
         backupManager.restore(new BackupChainLog(backupChainLogFile), reEntry.getName(), wEntry, false);
      }
      catch (InvalidItemStateException e)
      {
         restored = false;
         throw new WorkspaceRestoreExeption("Workspace '" + "/" + repositoryName + "/" + wEntry.getName()
            + "' can not be restored! There was database error!", e);

      }
      catch (Throwable t) //NOSONAR
      {
         restored = false;
         throw new WorkspaceRestoreExeption("Workspace '" + "/" + repositoryName + "/" + wEntry.getName()
            + "' can not be restored!", t);

      }
      finally
      {
         if (!restored)
         {
            try
            {
               removeWorkspace(repository, wEntry.getName());
            }
            catch (Throwable thr) //NOSONAR
            {
               throw new WorkspaceRestoreExeption("Workspace '" + "/" + repositoryName + "/"
                  + wEntry.getName() + "' can not be restored!", thr);
            }
         }
      }
   }