Performs the module update.<p>
492533
public void run() {

        try {
            CmsObject cms = m_moduleData.getCms();
            CmsModule module = m_moduleData.getModule();
            CmsModule oldModule = OpenCms.getModuleManager().getModule(module.getName());
            Map<CmsUUID, CmsUUID> conflictingIds = m_moduleData.getConflictingIds();
            if (!conflictingIds.isEmpty()) {
                deleteConflictingResources(cms, module, conflictingIds);
            }
            CmsProject importProject = createAndSetModuleImportProject(cms, module);
            CmsModuleImportExportHandler.reportBeginImport(m_report, module.getName());

            Map<CmsUUID, CmsResourceImportData> importResourcesById = new HashMap<>();
            for (CmsResourceImportData resData : m_moduleData.getResourceData()) {
                importResourcesById.put(resData.getResource().getStructureId(), resData);
            }
            Set<CmsResource> oldModuleResources = getAllResourcesInModule(cms, oldModule);
            List<CmsResource> toDelete = new ArrayList<>();
            Set<String> immutables = OpenCms.getImportExportManager().getImmutableResources().stream().flatMap(
                path -> Arrays.asList(
                    CmsFileUtil.removeTrailingSeparator(path),
                    CmsFileUtil.addTrailingSeparator(path)).stream()).collect(Collectors.toSet());
            for (CmsResource oldRes : oldModuleResources) {
                if (immutables.contains(oldRes.getRootPath())) {
                    continue;
                }
                CmsResourceImportData newRes = importResourcesById.get(oldRes.getStructureId());
                if (newRes == null) {
                    toDelete.add(oldRes);
                }
            }
            int index = 0;
            for (CmsResourceImportData resData1 : m_moduleData.getResourceData()) {
                index += 1;
                processImportResource(cms, resData1, index);
            }
            processDeletions(cms, toDelete);
            parseLinks(cms);

            importRelations(cms);
            if (!CmsStringUtil.isEmptyOrWhitespaceOnly(module.getImportScript())) {
                runImportScript(cms, module);
            }
            cms.unlockProject(importProject.getUuid());
            OpenCms.getModuleManager().updateModule(cms, module);
            module.setCheckpointTime(System.currentTimeMillis());
            // reinitialize the resource manager with additional module resource types if necessary
            if (module.getResourceTypes() != Collections.EMPTY_LIST) {
                OpenCms.getResourceManager().initialize(cms);
            }
            // reinitialize the workplace manager with additional module explorer types if necessary
            if (module.getExplorerTypes() != Collections.EMPTY_LIST) {
                OpenCms.getWorkplaceManager().addExplorerTypeSettings(module);
            }
            OpenCms.getPublishManager().publishProject(cms, m_report);
            OpenCms.getPublishManager().waitWhileRunning();
            CmsModuleImportExportHandler.reportEndImport(m_report);
        } catch (Exception e) {
            m_report.println(e);
        } finally {
            cleanUp();
        }
    }
632346
protected void update(CmsPublishJobInfoBean publishJob) {

        if (OpenCms.getMemoryMonitor().requiresPersistency()) {
            CmsDbContext dbc = m_publishEngine.getDbContext(null);
            try {
                m_publishEngine.getDriverManager().writePublishJob(dbc, publishJob);
            } catch (CmsException e) {
                dbc.rollback();
                if (LOG.isErrorEnabled()) {
                    LOG.error(e.getLocalizedMessage(), e);
                }
            } finally {
                dbc.clear();
            }
        }
    }
870930
public void editNewModule(Runnable callback) {

        CmsModule module = new CmsModule();
        module.setSite("/");

        editModule(module, true, CmsVaadinUtils.getMessageText(Messages.GUI_MODULES_TITLE_NEW_MODULE_0), callback);

    }
1125498
protected void performUpdate() {

        // Wrap a try-catch around everything, because an escaping exception would cancel the task from which this is called
        List<CmsWaitHandle> waitHandles = new ArrayList<>();
        try {
            ArrayList<Object> work = new ArrayList<>();
            m_workQueue.drainTo(work);
            Set<CmsUUID> updateIds = new HashSet<CmsUUID>();

            for (Object item : work) {
                if (item instanceof CmsUUID) {
                    updateIds.add((CmsUUID)item);
                } else if (item instanceof CmsWaitHandle) {
                    waitHandles.add((CmsWaitHandle)item);
                }
            }
            CmsADEConfigCacheState oldState = m_state;
            if (!updateIds.isEmpty() || (oldState == null)) {
                try {
                    // Although  the updates are performed in a scheduled task, it is still possible
                    // that the task is scheduled immediately after a configuration update event. So
                    // here we ensure that there is at least a small delay between the event and the
                    // actual update. This is required to prevent problems with other caches.
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // ignore
                }
                if (updateIds.contains(ID_UPDATE_ALL) || (oldState == null)) {
                    m_state = readCompleteConfiguration();
                } else {
                    boolean updateModules = updateIds.remove(ID_UPDATE_MODULES);
                    boolean updateElementViews = updateIds.remove(ID_UPDATE_ELEMENT_VIEWS);
                    updateIds.remove(ID_UPDATE_FOLDERTYPES); // folder types are always updated when the update set is not empty, so at this point we don't care whether the id for folder type updates actually is in the update set
                    Map<CmsUUID, CmsADEConfigDataInternal> updateMap = Maps.newHashMap();
                    for (CmsUUID structureId : updateIds) {
                        CmsADEConfigDataInternal sitemapConfig = parseSitemapConfiguration(structureId);
                        // sitemapConfig may be null at this point
                        updateMap.put(structureId, sitemapConfig);
                    }
                    List<CmsADEConfigDataInternal> moduleConfigs = null;
                    if (updateModules) {
                        moduleConfigs = loadModuleConfiguration();
                    }
                    Map<CmsUUID, CmsElementView> elementViews = null;
                    if (updateElementViews) {
                        elementViews = loadElementViews();
                    }
                    m_state = oldState.createUpdatedCopy(updateMap, moduleConfigs, elementViews);
                }
            }

        } catch (Exception e) {
            LOG.error("Could not perform configuration cache update: " + e.getMessage(), e);
        } finally {
            for (CmsWaitHandle handle : waitHandles) {
                handle.release();
            }
        }
    }
110377
public void addUpdate(final Update update) {
        if (updates == null) {
            updates = new ArrayList<Update>();
        }
        updates.add(update);
    }
256705
def update(self, module_name=None):
        
        if not module_name:
            return self._module.force_update()
        else:
            module_info = self._get_module_info(module_name)
            if module_info:
                module_info["module"].force_update()
541640
public void update(CmsEntity entity) {

        String removeAllFlag = CmsEntity.getValueForPath(entity, m_valuePath);

        boolean allRemoved = Boolean.valueOf(removeAllFlag).booleanValue();

        replaceOptions(allRemoved ? m_optionsAllRemoved : m_optionsDefault);
    }
331721
public void updateModule(String importFile) throws Exception {

        CmsModule module = CmsModuleImportExportHandler.readModuleFromImport(importFile);
        String moduleName = module.getName();
        String moduleVersion = module.getVersionStr();
        m_shell.getOut().println("Updating module " + moduleName + " version " + moduleVersion);
        if (OpenCms.getModuleManager().getModule(moduleName) != null) {

            String oldVersion = OpenCms.getModuleManager().getModule(moduleName).getVersionStr();
            m_shell.getOut().println("Previous version '" + oldVersion + "' detected");
            if (!oldVersion.equals(moduleVersion)) {
                // the import version does not equal the present module version, replace the module
                OpenCms.getModuleManager().replaceModule(
                    m_cms,
                    importFile,
                    new CmsShellReport(m_cms.getRequestContext().getLocale()));
            }
        } else {
            importModule(importFile);
        }
    }
766472
@Override
	public void update () {
		// Execute the global state (if any)
		if (globalState != null) globalState.update(owner);

		// Execute the current state (if any)
		if (currentState != null) currentState.update(owner);
	}
953741
@Override
  public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
    methodCalls.add(MethodCall.of("createUpdate").with("beanType", beanType, "ormUpdate", ormUpdate));
    return delegate.createUpdate(beanType, ormUpdate);
  }
74825
public void update()
   {
      ProjectProperties properties = m_projectFile.getProjectProperties();
      char decimalSeparator = properties.getDecimalSeparator();
      char thousandsSeparator = properties.getThousandsSeparator();
      m_unitsDecimalFormat.applyPattern("#.##", null, decimalSeparator, thousandsSeparator);
      m_decimalFormat.applyPattern("0.00#", null, decimalSeparator, thousandsSeparator);
      m_durationDecimalFormat.applyPattern("#.##", null, decimalSeparator, thousandsSeparator);
      m_percentageDecimalFormat.applyPattern("##0.##", null, decimalSeparator, thousandsSeparator);
      updateCurrencyFormats(properties, decimalSeparator, thousandsSeparator);
      updateDateTimeFormats(properties);
   }
744361
public void edit(
        CmsClientSitemapEntry entry,
        List<CmsPropertyModification> propertyChanges,
        final CmsReloadMode reloadStatus) {

        CmsSitemapChange change = getChangeForEdit(entry, propertyChanges);
        final String updateTarget = ((reloadStatus == CmsReloadMode.reloadParent))
        ? getParentEntry(entry).getSitePath()
        : entry.getSitePath();
        Command callback = new Command() {

            public void execute() {

                if ((reloadStatus == CmsReloadMode.reloadParent) || (reloadStatus == CmsReloadMode.reloadEntry)) {
                    updateEntry(updateTarget);
                }
            }
        };
        if (change != null) {
            commitChange(change, callback);
        }
    }
301589
private void updateChildrenInfo(Map myChild) {
        if (myChild != null) {
            Iterator values = myChild.values().iterator();
            while (values.hasNext()) {
                ModuleItem childMI = (ModuleItem) values.next();
                if (childMI.getInstance() instanceof PmiModuleAggregate) {
                    // no op                    
                } else {
                    ((PmiModuleAggregate) this.instance).add(childMI.getInstance());
                    ((PmiAbstractModule) this.instance).updateDataList();
                }
                updateChildrenInfo(childMI.children);
            }
        }
    }
95497
private void installModule(final Node node, final ModuleContext module, final Handler<AsyncResult<Void>> doneHandler) {
    node.installModule(module.module(), doneHandler);
  }
112351
public void setOldModule() {

        m_oldModule = true;
        if (LOG.isDebugEnabled()) {
            LOG.debug(Messages.get().getBundle().key(Messages.LOG_OLD_MODULE_IMPORTED_0));
        }
    }
1337383
protected void update(CmsUUID structureId, String rootPath, int type, CmsResourceState resState) {

        if (CmsResource.isTemporaryFileName(rootPath)) {
            return;
        }
        m_pathCache.replace(structureId, rootPath);
        if (isSitemapConfiguration(rootPath, type)) {
            m_workQueue.add(structureId);
        } else if (isModuleConfiguration(rootPath, type)) {
            LOG.info("Changed module configuration file " + rootPath + "(" + structureId + ")");
            m_workQueue.add(ID_UPDATE_MODULES);
        } else if (isElementView(type)) {
            m_workQueue.add(ID_UPDATE_ELEMENT_VIEWS);
        } else if (m_state.getFolderTypes().containsKey(rootPath)) {
            m_workQueue.add(ID_UPDATE_FOLDERTYPES);
        } else if (isMacroOrFlexFormatter(type, rootPath)) {
            try {
                String path = CmsResource.getParentFolder(CmsResource.getParentFolder(rootPath));
                path = CmsStringUtil.joinPaths(path, ".config");
                CmsResourceFilter filter = CmsResourceFilter.IGNORE_EXPIRATION;
                if (m_cms.existsResource(path, filter)) {

                    CmsResource config = m_cms.readResource(path, filter);
                    m_workQueue.add(config.getStructureId());
                }
            } catch (Exception e) {
                LOG.warn(e.getMessage(), e);
            }
        }
    }
1161260
private void updateFromPicker() {

        checkTime();
        Date date = m_picker.getValue();
        if (!m_dateOnly) {
            String timeAsString = getTimeText();
            date = CmsDateConverter.getDateWithTime(date, timeAsString);
        }
        setValue(date);
        setErrorMessage(null);
        fireChange(date, false);
    }