Java ExtensibleConfigurationPersister类代码示例

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
@Override
public void initCoreModel(Resource rootResource, ManagementResourceRegistration rootRegistration, Resource modelControllerResource) {
    VersionModelInitializer.registerRootResource(rootResource, null);
    final HostControllerEnvironment env = createHostControllerEnvironment();
    final LocalHostControllerInfoImpl info = createLocalHostControllerInfo(env);
    final IgnoredDomainResourceRegistry ignoredRegistry = new IgnoredDomainResourceRegistry(info);
    final ExtensibleConfigurationPersister persister = new NullConfigurationPersister();
    final HostFileRepository hostFileRepository = createHostFileRepository();

    DomainRootDefinition domainDefinition = new DomainRootDefinition(env, persister, injectedContentRepository.getValue(),
            hostFileRepository, true, info, extensionRegistry, null, pathManagerService, authorizer);
    domainDefinition.initialize(rootRegistration);
    rootResourceDefinition.setDelegate(domainDefinition);

    HostModelUtil.createRootRegistry(
            rootRegistration,
            env, ignoredRegistry,
            new HostModelRegistrar() {

                @Override
                public void registerHostModel(String hostName, ManagementResourceRegistration root) {
                }
            },processType, authorizer, modelControllerResource);

    CoreManagementResourceDefinition.registerDomainResource(rootResource, null);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public static ExtensibleConfigurationPersister createHostXmlConfigurationPersister(final ConfigurationFile file, final HostControllerEnvironment environment,
                                                                                   final ExecutorService executorService, final ExtensionRegistry hostExtensionRegistry,
                                                                                   final LocalHostControllerInfo localHostControllerInfo) {
    String defaultHostname = localHostControllerInfo.getLocalHostName();
    if (environment.getRunningModeControl().isReloaded()) {
        if (environment.getRunningModeControl().getReloadHostName() != null) {
            defaultHostname = environment.getRunningModeControl().getReloadHostName();
        }
    }
    HostXml hostXml = new HostXml(defaultHostname, environment.getRunningModeControl().getRunningMode(),
            environment.isUseCachedDc(), Module.getBootModuleLoader(), executorService, hostExtensionRegistry);
    BackupXmlConfigurationPersister persister = new BackupXmlConfigurationPersister(file, new QName(Namespace.CURRENT.getUriString(), "host"), hostXml, hostXml, false);
    for (Namespace namespace : Namespace.domainValues()) {
        if (!namespace.equals(Namespace.CURRENT)) {
            persister.registerAdditionalRootElement(new QName(namespace.getUriString(), "host"), hostXml);
        }
    }
    hostExtensionRegistry.setWriterRegistry(persister);
    return persister;
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public static ExtensibleConfigurationPersister createDomainXmlConfigurationPersister(final ConfigurationFile file, ExecutorService executorService, ExtensionRegistry extensionRegistry, final HostControllerEnvironment environment) {
    DomainXml domainXml = new DomainXml(Module.getBootModuleLoader(), executorService, extensionRegistry);

    boolean suppressLoad = false;
    ConfigurationFile.InteractionPolicy policy = file.getInteractionPolicy();
    final boolean isReloaded = environment.getRunningModeControl().isReloaded();

    if (!isReloaded && (policy == ConfigurationFile.InteractionPolicy.NEW && (file.getBootFile().exists() && file.getBootFile().length() != 0))) {
        throw HostControllerLogger.ROOT_LOGGER.cannotOverwriteDomainXmlWithEmpty(file.getBootFile().getName());
    }

    if (!isReloaded && (policy == ConfigurationFile.InteractionPolicy.NEW || policy == ConfigurationFile.InteractionPolicy.DISCARD)) {
        suppressLoad = true;
    }

    BackupXmlConfigurationPersister persister = new BackupXmlConfigurationPersister(file, new QName(Namespace.CURRENT.getUriString(), "domain"), domainXml, domainXml, suppressLoad);
    for (Namespace namespace : Namespace.domainValues()) {
        if (!namespace.equals(Namespace.CURRENT)) {
            persister.registerAdditionalRootElement(new QName(namespace.getUriString(), "domain"), domainXml);
        }
    }
    extensionRegistry.setWriterRegistry(persister);
    return persister;
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
@Override
public void initCoreModel(Resource rootResource, ManagementResourceRegistration rootRegistration, Resource modelControllerResource) {
    VersionModelInitializer.registerRootResource(rootResource, null);
    final HostControllerEnvironment env = createHostControllerEnvironment();
    final LocalHostControllerInfoImpl info = createLocalHostControllerInfo(env);
    final IgnoredDomainResourceRegistry ignoredRegistry = new IgnoredDomainResourceRegistry(info);
    final ExtensibleConfigurationPersister persister = new NullConfigurationPersister();
    final HostFileRepository hostFileRepository = createHostFileRepository();
    final DomainController domainController = createDomainController(env, info);
    final DomainHostExcludeRegistry domainHostExcludeRegistry = new DomainHostExcludeRegistry();

    DomainRootDefinition domainDefinition = new DomainRootDefinition(
            domainController,
            env,
            persister,
            injectedContentRepository.getValue(),
            hostFileRepository,
            true,
            info,
            extensionRegistry,
            null,
            pathManagerService,
            authorizer,
            null,
            null,
            domainHostExcludeRegistry,
            getMutableRootResourceRegistrationProvider());
    domainDefinition.initialize(rootRegistration);
    rootResourceDefinition.setDelegate(domainDefinition);

    HostModelUtil.createRootRegistry(
            rootRegistration,
            env, ignoredRegistry,
            (hostName, root) -> {},
            processType,
            authorizer,
            modelControllerResource);
    CoreManagementResourceDefinition.registerDomainResource(rootResource, null);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
@Override
public void initCoreModel(Resource rootResource, ManagementResourceRegistration rootRegistration, Resource modelControllerResource) {
    VersionModelInitializer.registerRootResource(rootResource, null);
    final HostControllerEnvironment env = createHostControllerEnvironment();
    final LocalHostControllerInfoImpl info = createLocalHostControllerInfo(env);
    final IgnoredDomainResourceRegistry ignoredRegistry = new IgnoredDomainResourceRegistry(info);
    final ExtensibleConfigurationPersister persister = new NullConfigurationPersister();
    final HostFileRepository hostFileRepository = createHostFileRepository();
    final DomainController domainController = createDomainController(env, info);
    final DomainHostExcludeRegistry domainHostExcludeRegistry = new DomainHostExcludeRegistry();

    DomainRootDefinition domainDefinition = new DomainRootDefinition(
            domainController,
            env,
            persister,
            injectedContentRepository.getValue(),
            hostFileRepository,
            true,
            info,
            extensionRegistry,
            null,
            pathManagerService,
            authorizer,
            null,
            domainHostExcludeRegistry,
            getMutableRootResourceRegistrationProvider());
    domainDefinition.initialize(rootRegistration);
    rootResourceDefinition.setDelegate(domainDefinition);

    HostModelUtil.createRootRegistry(
            rootRegistration,
            env, ignoredRegistry,
            (hostName, root) -> {},
            processType,
            authorizer,
            modelControllerResource);
    CoreManagementResourceDefinition.registerDomainResource(rootResource, null);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public void initializeMasterDomainRegistry(final ManagementResourceRegistration root,
        final ExtensibleConfigurationPersister configurationPersister, final ContentRepository contentRepository,
        final HostFileRepository fileRepository,
        final ExtensionRegistry extensionRegistry, final PathManagerService pathManager) {
    initializeDomainResource(root, configurationPersister, contentRepository, fileRepository, true,
            hostControllerInfo, extensionRegistry, null, pathManager);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public void initializeSlaveDomainRegistry(final ManagementResourceRegistration root,
        final ExtensibleConfigurationPersister configurationPersister, final ContentRepository contentRepository,
        final HostFileRepository fileRepository, final LocalHostControllerInfo hostControllerInfo,
        final ExtensionRegistry extensionRegistry,
        final IgnoredDomainResourceRegistry ignoredDomainResourceRegistry, final PathManagerService pathManagery) {
    initializeDomainResource(root, configurationPersister, contentRepository, fileRepository, false, hostControllerInfo,
            extensionRegistry, ignoredDomainResourceRegistry, pathManager);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
private void initializeDomainResource(final ManagementResourceRegistration root, final ExtensibleConfigurationPersister configurationPersister,
        final ContentRepository contentRepo, final HostFileRepository fileRepository, final boolean isMaster,
        final LocalHostControllerInfo hostControllerInfo,
        final ExtensionRegistry extensionRegistry, final IgnoredDomainResourceRegistry ignoredDomainResourceRegistry,
        final PathManagerService pathManager) {

    DomainRootDefinition domainRootDefinition = new DomainRootDefinition(this, environment, configurationPersister, contentRepo, fileRepository, isMaster, hostControllerInfo,
            extensionRegistry, ignoredDomainResourceRegistry, pathManager, authorizer, securityIdentitySupplier, this, domainHostExcludeRegistry, getMutableRootResourceRegistrationProvider());
    rootResourceDefinition.setDelegate(domainRootDefinition, root);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public static ExtensibleConfigurationPersister createRemoteBackupDomainXmlConfigurationPersister(final File configDir, ExecutorService executorService, ExtensionRegistry extensionRegistry) {
    DomainXml domainXml = new DomainXml(Module.getBootModuleLoader(), executorService, extensionRegistry);
    File bootFile = new File(configDir, CACHED_DOMAIN_XML_BOOTFILE);
    File file = new File(configDir, CACHED_DOMAIN_XML);
    BackupRemoteDomainXmlPersister persister = new BackupRemoteDomainXmlPersister(file, bootFile, new QName(Namespace.CURRENT.getUriString(), "domain"), domainXml, domainXml);
    for (Namespace namespace : Namespace.domainValues()) {
        if (!namespace.equals(Namespace.CURRENT)) {
            persister.registerAdditionalRootElement(new QName(namespace.getUriString(), "domain"), domainXml);
        }
    }
    extensionRegistry.setWriterRegistry(persister);
    return persister;
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public DomainRootDefinition(
        final DomainController domainController,
        final HostControllerEnvironment environment,
        final ExtensibleConfigurationPersister configurationPersister, final ContentRepository contentRepo,
        final HostFileRepository fileRepository, final boolean isMaster,
        final LocalHostControllerInfo hostControllerInfo,
        final ExtensionRegistry extensionRegistry, final IgnoredDomainResourceRegistry ignoredDomainResourceRegistry,
        final PathManagerService pathManager,
        final DelegatingConfigurableAuthorizer authorizer,
        final ManagementSecurityIdentitySupplier securityIdentitySupplier,
        final HostRegistrations hostRegistrations,
        final DomainHostExcludeRegistry domainHostExcludeRegistry,
        final MutableRootResourceRegistrationProvider rootResourceRegistrationProvider) {
    super(null, DomainResolver.getResolver(DOMAIN, false));
    this.domainController = domainController;
    this.isMaster = isMaster;
    this.environment = environment;
    this.hostControllerInfo = hostControllerInfo;
    this.configurationPersister = configurationPersister;
    this.contentRepo = contentRepo;
    this.fileRepository = fileRepository;
    this.extensionRegistry = extensionRegistry;
    this.ignoredDomainResourceRegistry = ignoredDomainResourceRegistry;
    this.pathManager = pathManager;
    this.authorizer = authorizer;
    this.securityIdentitySupplier = securityIdentitySupplier;
    this.hostRegistrations = hostRegistrations;
    this.domainHostExcludeRegistry = domainHostExcludeRegistry;
    this.rootResourceRegistrationProvider = rootResourceRegistrationProvider;
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
@Override
public void setDelegate() {
    final ExtensibleConfigurationPersister configurationPersister = new EmptyConfigurationPersister();
    final boolean isMaster = false;
    final IgnoredDomainResourceRegistry ignoredDomainResourceRegistry = new IgnoredDomainResourceRegistry(hostControllerInfo);
    final PathManagerService pathManager = new HostPathManagerService(capabilityRegistry);
    final DelegatingConfigurableAuthorizer authorizer = new DelegatingConfigurableAuthorizer();
    final ManagementSecurityIdentitySupplier securityIdentitySupplier = new ManagementSecurityIdentitySupplier();
    final HostRegistrations hostRegistrations = null;
    final DomainHostExcludeRegistry domainHostExcludeRegistry = new DomainHostExcludeRegistry();
    final MutableRootResourceRegistrationProvider rootResourceRegistrationProvider = new MutableRootResourceRegistrationProvider() {
        @Override
        public ManagementResourceRegistration getRootResourceRegistrationForUpdate(OperationContext context) {
            return managementModel.getRootResourceRegistration();
        }
    };
    DomainRootDefinition domain = new DomainRootDefinition(domainController, hostControllerEnvironment, configurationPersister,
            repository, repository, isMaster, hostControllerInfo, extensionRegistry, ignoredDomainResourceRegistry,
            pathManager, authorizer, securityIdentitySupplier, hostRegistrations, domainHostExcludeRegistry, rootResourceRegistrationProvider);
    getDelegatingResourceDefiniton().setDelegate(domain);

    final String hostName = hostControllerEnvironment.getHostName();
    final HostControllerConfigurationPersister hostControllerConfigurationPersister =
            new HostControllerConfigurationPersister(hostControllerEnvironment,
                    hostControllerInfo, Executors.newCachedThreadPool(), extensionRegistry, extensionRegistry);
    final HostRunningModeControl runningModeControl = new HostRunningModeControl(RunningMode.NORMAL, RestartMode.SERVERS);
    final ServerInventory serverInventory = null;
    final HostFileRepository remoteFileRepository = repository;
    final AbstractVaultReader vaultReader = null;
    final ControlledProcessState processState = null;
    final ManagedAuditLogger auditLogger = null;
    final BootErrorCollector bootErrorCollector = null;
    //Save this for later since setDelegate() gets called before initModel....
    hostResourceDefinition = new HostResourceDefinition(hostName, hostControllerConfigurationPersister,
            hostControllerEnvironment, runningModeControl, repository, hostControllerInfo, serverInventory, remoteFileRepository,
            repository, domainController, extensionRegistry, vaultReader, ignoredDomainResourceRegistry, processState,
            pathManager, authorizer, securityIdentitySupplier, auditLogger, bootErrorCollector);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
/**
 * Get the factory for the configuration persister to use.
 *
 * @return the configuration persister factory
 */
public synchronized ConfigurationPersisterFactory getConfigurationPersisterFactory() {
    if (configurationPersisterFactory == null) {
        configurationPersisterFactory = new ConfigurationPersisterFactory() {
            @Override
            public ExtensibleConfigurationPersister createConfigurationPersister(ServerEnvironment serverEnvironment, ExecutorService executorService) {
                ConfigurationFile configurationFile = serverEnvironment.getServerConfigurationFile();
                if (runningModeControl.isReloaded()) {
                    configurationFile.resetBootFile(runningModeControl.isUseCurrentConfig(), runningModeControl.getAndClearNewBootFileName());
                }
                QName rootElement = new QName(Namespace.CURRENT.getUriString(), "server");
                StandaloneXml parser = new StandaloneXml(Module.getBootModuleLoader(), executorService, extensionRegistry);
                BackupXmlConfigurationPersister persister = new BackupXmlConfigurationPersister(configurationFile, rootElement, parser, parser,
                        runningModeControl.isReloaded(), serverEnvironment.getLaunchType() == ServerEnvironment.LaunchType.EMBEDDED);
                for (Namespace namespace : Namespace.domainValues()) {
                    if (!namespace.equals(Namespace.CURRENT)) {
                        persister.registerAdditionalRootElement(new QName(namespace.getUriString(), "server"), parser);
                    }
                }
                extensionRegistry.setWriterRegistry(persister);
                return persister;
            }

            private boolean isNewConfiguration(ConfigurationFile.InteractionPolicy interactionPolicy) {
                return interactionPolicy == ConfigurationFile.InteractionPolicy.NEW
                        || interactionPolicy == ConfigurationFile.InteractionPolicy.DISCARD;
            }
        };
    }
    return configurationPersisterFactory;
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
@Override
public void initializeSlaveDomainRegistry(ManagementResourceRegistration root,
        ExtensibleConfigurationPersister configurationPersister, ContentRepository contentRepository,
        HostFileRepository fileRepository, LocalHostControllerInfo hostControllerInfo,
        ExtensionRegistry extensionRegistry, IgnoredDomainResourceRegistry ignoredDomainResourceRegistry,
        PathManagerService pathManager) {
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public static ExtensibleConfigurationPersister createCachedRemoteDomainXmlConfigurationPersister(final File configDir, ExecutorService executorService, ExtensionRegistry extensionRegistry) {
    return createRemoteBackupDomainXmlConfigurationPersister(configDir, executorService, extensionRegistry);
}
 

import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister; //导入依赖的package包/类
public static ExtensibleConfigurationPersister createTransientDomainXmlConfigurationPersister(ExecutorService executorService, ExtensionRegistry extensionRegistry) {
    DomainXml domainXml = new DomainXml(Module.getBootModuleLoader(), executorService, extensionRegistry);
    ExtensibleConfigurationPersister persister = new NullConfigurationPersister(domainXml);
    extensionRegistry.setWriterRegistry(persister);
    return persister;
}