diff --git a/tc-server/src/main/java/com/tc/config/ServerConfigurationManager.java b/tc-server/src/main/java/com/tc/config/ServerConfigurationManager.java index 18c34b1b6d..2a0c2ed803 100644 --- a/tc-server/src/main/java/com/tc/config/ServerConfigurationManager.java +++ b/tc-server/src/main/java/com/tc/config/ServerConfigurationManager.java @@ -17,7 +17,6 @@ */ package com.tc.config; - import com.tc.classloader.ServiceLocator; import com.tc.productinfo.ProductInfo; import com.tc.properties.TCPropertiesImpl; @@ -28,7 +27,6 @@ import java.io.ByteArrayInputStream; import java.io.InputStream; import java.nio.charset.StandardCharsets; -import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Map; @@ -36,26 +34,35 @@ import java.util.Properties; import org.terracotta.configuration.ConfigurationException; import com.tc.text.PrettyPrintable; +import java.io.Closeable; +import java.io.File; +import java.net.InetSocketAddress; import java.util.List; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.stream.Collectors; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.terracotta.configuration.FailoverBehavior; +import org.terracotta.entity.ServiceProviderConfiguration; public class ServerConfigurationManager implements PrettyPrintable { - private final ConfigurationProvider configurationProvider; + private final Logger LOGGER = LoggerFactory.getLogger(ServerConfigurationManager.class); + private final CachingConfigurationProvider configurationProvider; + private ServerConfiguration thisServer; private final ServiceLocator serviceLocator; private final List startUpArgs; private final ProductInfo productInfo; - private Configuration configuration; - private ServerConfiguration serverConfiguration; - public ServerConfigurationManager(ConfigurationProvider configurationProvider, - ServiceLocator classLoader, - List startUpArgs) { + ServiceLocator classLoader, + List startUpArgs) { Objects.requireNonNull(configurationProvider); Objects.requireNonNull(classLoader); Objects.requireNonNull(startUpArgs); - this.configurationProvider = configurationProvider; + this.configurationProvider = new CachingConfigurationProvider(configurationProvider); this.serviceLocator = classLoader; this.startUpArgs = startUpArgs; this.productInfo = generateProductInfo(serviceLocator); @@ -70,18 +77,19 @@ public ProductInfo getProductInfo() { } public void initialize() throws ConfigurationException { - this.configurationProvider.initialize(this.startUpArgs); - - this.configuration = configurationProvider.getConfiguration(); - if (this.configuration == null) { - throw new ConfigurationException("unable to determine server configuration"); - } + try (LockedConfiguration configuration = this.configurationProvider.lockAndInitialize(this.startUpArgs)) { + if (configuration == null) { + throw new ConfigurationException("unable to determine server configuration"); + } + + ServerConfiguration base = configuration.getServerConfiguration(); + if (base == null) { + throw new ConfigurationException("unable to determine server configuration"); + } + thisServer = new StableServerConfiguration(base); - this.serverConfiguration = this.configuration.getServerConfiguration(); - if (this.serverConfiguration == null) { - throw new ConfigurationException("unable to determine server configuration"); + processTcProperties(configuration.getTcProperties()); } - processTcProperties(configuration.getTcProperties()); } public void close() { @@ -93,58 +101,92 @@ public String[] getProcessArguments() { } public ServerConfiguration getServerConfiguration() { - return this.serverConfiguration; + return thisServer; } public GroupConfiguration getGroupConfiguration() { - List serverConfigurationMap = configuration.getServerConfigurations(); - return new GroupConfiguration(serverConfigurationMap, this.serverConfiguration.getName()); + List serverConfigurationMap = configurationProvider.getStableServerConfigurations(); + return new GroupConfiguration(serverConfigurationMap, getServerConfiguration().getName()); } - + public InputStream rawConfigFile() { - String text = configuration.getRawConfiguration(); - return new ByteArrayInputStream(text.getBytes(StandardCharsets.UTF_8)); + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + String text = config.getRawConfiguration(); + return new ByteArrayInputStream(text.getBytes(StandardCharsets.UTF_8)); + } } public String rawConfigString() { - return configuration.getRawConfiguration(); + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.getRawConfiguration(); + } } public String[] allCurrentlyKnownServers() { return getGroupConfiguration().getMembers(); } - + + public boolean isConsistentStartup() { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.isConsistentStartup(); + } + } + public boolean isPartialConfiguration() { - return this.configuration.isPartialConfiguration(); + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.isPartialConfiguration(); + } + } + + public boolean isRelaySource() { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.isRelaySource(); + } + } + + public boolean isRelayDestination() { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.isRelayDestination(); + } + } + + public InetSocketAddress getRelayPeer() { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.getRelayPeer(); + } + } + + public FailoverBehavior getFailoverPriority() { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.getFailoverPriority(); + } + } + + public List getExtendedConfiguration(Class type) { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.getExtendedConfiguration(type); + } } + public List getServiceConfigurations() { + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + return config.getServiceConfigurations(); + } + } + public ServiceLocator getServiceLocator() { return this.serviceLocator; } - public Configuration getConfiguration() { - return configuration; - } - public ConfigurationProvider getConfigurationProvider() { - return configurationProvider; - } - - private Map getServerConfigurationMap(Collection servers) { - Map serverConfigurationMap = new HashMap<>(); - for (ServerConfiguration server : servers) { - if (server.getName() != null) { - serverConfigurationMap.put(server.getName(), server); - } - } - return serverConfigurationMap; + return configurationProvider.delegateProvider; } private static void processTcProperties(Properties tcProperties) { Map propMap = new HashMap<>(); if (tcProperties != null) { - tcProperties.forEach((k, v)->propMap.put(k.toString().trim(), v.toString().trim())); + tcProperties.forEach((k, v) -> propMap.put(k.toString().trim(), v.toString().trim())); } TCPropertiesImpl.getProperties().overwriteTcPropertiesFromConfig(propMap); @@ -152,10 +194,205 @@ private static void processTcProperties(Properties tcProperties) { @Override public Map getStateMap() { - if (configuration instanceof PrettyPrintable) { - return ((PrettyPrintable)configuration).getStateMap(); - } else { - return Collections.emptyMap(); + try (LockedConfiguration config = configurationProvider.getLockedConfiguration()) { + if (config instanceof PrettyPrintable) { + return ((PrettyPrintable) config).getStateMap(); + } else { + return Collections.emptyMap(); + } + } + } + + private static class LockedConfiguration implements Configuration, Closeable { + private final Configuration delegate; + private final Lock close; + + public LockedConfiguration(Configuration delegate, Lock close) { + this.delegate = delegate; + this.close = close; + } + + public void close() { + close.unlock(); + } + + @Override + public ServerConfiguration getServerConfiguration() throws ConfigurationException { + return delegate.getServerConfiguration(); + } + + @Override + public List getServerConfigurations() { + return delegate.getServerConfigurations(); + } + + @Override + public List getServiceConfigurations() { + return delegate.getServiceConfigurations(); + } + + @Override + public List getExtendedConfiguration(Class type) { + return delegate.getExtendedConfiguration(type); + } + + @Override + public String getRawConfiguration() { + return delegate.getRawConfiguration(); + } + + @Override + public Properties getTcProperties() { + return delegate.getTcProperties(); + } + + @Override + public FailoverBehavior getFailoverPriority() { + return delegate.getFailoverPriority(); + } + + @Override + public boolean isConsistentStartup() { + return delegate.isConsistentStartup(); + } + + @Override + public boolean isPartialConfiguration() { + return delegate.isPartialConfiguration(); + } + + @Override + public boolean isRelaySource() { + return delegate.isRelaySource(); + } + + @Override + public boolean isRelayDestination() { + return delegate.isRelayDestination(); + } + + @Override + public InetSocketAddress getRelayPeer() { + return delegate.getRelayPeer(); + } + } + + private static final class CachingConfigurationProvider implements ConfigurationProvider { + + private final ConfigurationProvider delegateProvider; + private final Lock lock = new ReentrantLock(); + + public CachingConfigurationProvider(ConfigurationProvider delegateProvider) { + this.delegateProvider = delegateProvider; + } + + List getStableServerConfigurations() { + lock.lock(); + try { + return delegateProvider.getConfiguration().getServerConfigurations().stream().map(StableServerConfiguration::new).collect(Collectors.toList()); + } finally { + lock.unlock(); + } + } + + LockedConfiguration lockAndInitialize(List configurationParams) throws ConfigurationException { + lock.lock(); + initialize(configurationParams); + return new LockedConfiguration(delegateProvider.getConfiguration(), lock); + } + + @Override + public void initialize(List configurationParams) throws ConfigurationException { + delegateProvider.initialize(configurationParams); + } + + public LockedConfiguration getLockedConfiguration() { + lock.lock(); + return new LockedConfiguration(delegateProvider.getConfiguration(), lock); + } + + @Override + public Configuration getConfiguration() { + lock.lock(); + try { + return delegateProvider.getConfiguration(); + } finally { + lock.unlock(); + } + } + + @Override + public String getConfigurationParamsDescription() { + return delegateProvider.getConfigurationParamsDescription(); + } + + @Override + public void close() { + delegateProvider.close(); + } + + @Override + public byte[] getSyncData() { + return delegateProvider.getSyncData(); + } + + @Override + public void sync(byte[] syncData) { + lock.lock(); + try { + delegateProvider.sync(syncData); + } finally { + lock.unlock(); + } + } + } + + private static class StableServerConfiguration implements ServerConfiguration { + + private final InetSocketAddress tsaPort; + private final InetSocketAddress groupPort; + private final String host; + private final String name; + private final int reconnectWindow; + private final File logDir; + + public StableServerConfiguration(ServerConfiguration base) { + tsaPort = base.getTsaPort(); + groupPort = base.getGroupPort(); + host = base.getHost(); + name = base.getName(); + reconnectWindow = base.getClientReconnectWindow(); + logDir = base.getLogsLocation(); + } + + @Override + public InetSocketAddress getTsaPort() { + return tsaPort; + } + + @Override + public InetSocketAddress getGroupPort() { + return groupPort; + } + + @Override + public String getHost() { + return host; + } + + @Override + public String getName() { + return name; + } + + @Override + public int getClientReconnectWindow() { + return reconnectWindow; + } + + @Override + public File getLogsLocation() { + return logDir; } } } diff --git a/tc-server/src/main/java/com/tc/l2/ha/L2HACoordinator.java b/tc-server/src/main/java/com/tc/l2/ha/L2HACoordinator.java index 44aedf4322..410a6fec33 100644 --- a/tc-server/src/main/java/com/tc/l2/ha/L2HACoordinator.java +++ b/tc-server/src/main/java/com/tc/l2/ha/L2HACoordinator.java @@ -23,7 +23,6 @@ import com.tc.l2.api.L2Coordinator; import com.tc.l2.api.ReplicatedClusterStateManager; import com.tc.l2.state.ConsistencyManager; -import com.tc.l2.state.ServerMode; import com.tc.l2.state.StateManager; import com.tc.net.NodeID; import com.tc.net.groups.AbstractGroupMessage; @@ -103,12 +102,12 @@ public void connectionIDDestroyed(ConnectionID connectionID) { @Override public void start() { - if (this.server.getConfigSetupManager().getConfiguration().isPartialConfiguration()) { + if (this.server.getConfigSetupManager().isPartialConfiguration()) { this.stateManager.moveToDiagnosticMode(); consoleLogger.info("Started the server in diagnostic mode"); - } else if (this.server.getConfigSetupManager().getConfiguration().isRelaySource()) { + } else if (this.server.getConfigSetupManager().isRelaySource()) { this.stateManager.moveToRelayMode(); - } else if (this.server.getConfigSetupManager().getConfiguration().isRelayDestination()) { + } else if (this.server.getConfigSetupManager().isRelayDestination()) { this.stateManager.moveToRelayMode(); } this.stateManager.initializeAndStartElection(); diff --git a/tc-server/src/main/java/com/tc/l2/ha/TopologyWeightGenerator.java b/tc-server/src/main/java/com/tc/l2/ha/TopologyWeightGenerator.java index cf9a8fe857..d5a8611e63 100644 --- a/tc-server/src/main/java/com/tc/l2/ha/TopologyWeightGenerator.java +++ b/tc-server/src/main/java/com/tc/l2/ha/TopologyWeightGenerator.java @@ -17,24 +17,24 @@ */ package com.tc.l2.ha; +import com.tc.config.ServerConfigurationManager; import com.tc.l2.ha.WeightGeneratorFactory.WeightGenerator; -import org.terracotta.configuration.Configuration; public class TopologyWeightGenerator implements WeightGenerator { - private final Configuration configuration; + private final ServerConfigurationManager configuration; private final int initialSize; - public TopologyWeightGenerator(Configuration config) { + public TopologyWeightGenerator(ServerConfigurationManager config) { this.configuration = config; - this.initialSize = config.getServerConfigurations().size(); + this.initialSize = config.getGroupConfiguration().getNodes().size(); } @Override public long getWeight() { try { - return configuration.getServerConfigurations().size(); + return configuration.getGroupConfiguration().getNodes().size(); } catch (Throwable t) { return initialSize; } diff --git a/tc-server/src/main/java/com/tc/net/groups/TCGroupManagerImpl.java b/tc-server/src/main/java/com/tc/net/groups/TCGroupManagerImpl.java index de799d0acf..5be5815d65 100755 --- a/tc-server/src/main/java/com/tc/net/groups/TCGroupManagerImpl.java +++ b/tc-server/src/main/java/com/tc/net/groups/TCGroupManagerImpl.java @@ -167,9 +167,9 @@ public TCGroupManagerImpl(ServerConfigurationManager configSetupManager, Connect this.thisNodeID = thisNodeID; this.bufferManagerFactory = bufferManagerFactory; this.version = configSetupManager.getProductInfo().version(); - this.relayLocation = configSetupManager.getConfiguration().getRelayPeer(); + this.relayLocation = configSetupManager.getRelayPeer(); this.configuredNodes = ()-> { - if (configSetupManager.getConfiguration().isRelayDestination()) { + if (configSetupManager.isRelayDestination()) { return configSetupManager.getGroupConfiguration().directConnect(relayLocation).getNodes(); } else { return configSetupManager.getGroupConfiguration().getNodes(); diff --git a/tc-server/src/main/java/com/tc/objectserver/impl/DistributedObjectServer.java b/tc-server/src/main/java/com/tc/objectserver/impl/DistributedObjectServer.java index e87844d9e7..613397d966 100644 --- a/tc-server/src/main/java/com/tc/objectserver/impl/DistributedObjectServer.java +++ b/tc-server/src/main/java/com/tc/objectserver/impl/DistributedObjectServer.java @@ -316,8 +316,7 @@ public DistributedObjectServer(ServerConfigurationManager configSetupManager, TC this.serverBuilder = createServerBuilder(configSetupManager.getGroupConfiguration(), logger, server); this.serviceRegistry = new TerracottaServiceProviderRegistryImpl(); this.topologyManager = new TopologyManager(()->this.configSetupManager.getGroupConfiguration().getHostPorts(), ()-> { - Configuration config = this.configSetupManager.getConfiguration(); - FailoverBehavior consistent = config.getFailoverPriority(); + FailoverBehavior consistent = this.configSetupManager.getFailoverPriority(); if (this.configSetupManager.isPartialConfiguration() || consistent == null || consistent.isAvailability()) { return -1; } else { @@ -484,10 +483,9 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep this.sampledCounterManager = new CounterManagerImpl(); // Set up the ServiceRegistry. - Configuration configuration = this.configSetupManager.getConfiguration(); PlatformConfiguration platformConfiguration = - new PlatformConfigurationImpl(configSetupManager.getServerConfiguration(), configuration); - serviceRegistry.initialize(platformConfiguration, configuration); + new PlatformConfigurationImpl(configSetupManager); + serviceRegistry.initialize(platformConfiguration, configSetupManager); serviceRegistry.registerImplementationProvided(new PlatformServiceProvider(server)); final EntityMessengerProvider messengerProvider = new EntityMessengerProvider(); @@ -526,7 +524,7 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep } } - if (configuration.isPartialConfiguration() || configuration.isRelaySource()) { + if (configSetupManager.isPartialConfiguration() || configSetupManager.isRelaySource()) { // don't persist anything for partial configurations persistor = new NullPersistor(); } else { @@ -587,7 +585,7 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep ClientStatePersistor clientStateStore = this.persistor.getClientStatePersistor(); this.connectionIdFactory = new ConnectionIDFactoryImpl(infoConnections, clientStateStore, capablities); int voteCount = - ConsistencyManager.parseVoteCount(configuration.getFailoverPriority(), configuration.getServerConfigurations().size()); + ConsistencyManager.parseVoteCount(configSetupManager.getFailoverPriority(), configSetupManager.getGroupConfiguration().getNodes().size()); int knownPeers = this.configSetupManager.allCurrentlyKnownServers().length - 1; if (voteCount >= 0 && (voteCount + knownPeers + 1) % 2 == 0) { @@ -615,9 +613,9 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep final DSOChannelManager channelManager = new DSOChannelManagerImpl(this.l1Listener.getChannelManager(), pInfo.version()); channelManager.addEventListener(this.connectionIdFactory); - ServerPersistentState serverPersistentState = configuration.isRelaySource() ? new RelayPersistentState() : new ClusterPersistentState(this.persistor.getClusterStatePersistor()); + ServerPersistentState serverPersistentState = configSetupManager.isRelaySource() ? new RelayPersistentState() : new ClusterPersistentState(this.persistor.getClusterStatePersistor()); - if (serverPersistentState.getInitialMode() == ServerMode.ACTIVE && configuration.isRelayDestination()) { + if (serverPersistentState.getInitialMode() == ServerMode.ACTIVE && configSetupManager.isRelayDestination()) { throw new TCShutdownServerException("Unable to start as a relay destination. The server was shutdown as active"); } @@ -641,7 +639,7 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep final InitialStateWeightGenerator initialState = new InitialStateWeightGenerator(serverPersistentState); weightGeneratorFactory.add(initialState); // 5) Topology weight is the number nodes this stripe believes are in the cluster - final TopologyWeightGenerator topoWeight = new TopologyWeightGenerator(this.configSetupManager.getConfiguration()); + final TopologyWeightGenerator topoWeight = new TopologyWeightGenerator(this.configSetupManager); weightGeneratorFactory.add(topoWeight); // 6) SequenceID weight is the number of replication activities handled by this passive server final SequenceIDWeightGenerator sequenceWeight = new SequenceIDWeightGenerator(); @@ -721,7 +719,7 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep HASettingsChecker haChecker = new HASettingsChecker(configSetupManager, tcProperties); haChecker.validateHealthCheckSettingsForHighAvailability(); - StateManager state = new StateManagerImpl(consoleLogger, (n)->!configuration.isRelayDestination(), this.groupCommManager, + StateManager state = new StateManagerImpl(consoleLogger, (n)->!configSetupManager.isRelayDestination(), this.groupCommManager, createStageController(processTransactionHandler), eventCollector, stageManager, configSetupManager.getGroupConfiguration().getNodes().size(), configSetupManager.getGroupConfiguration().getElectionTimeInSecs(), @@ -733,13 +731,13 @@ public synchronized void bootstrap() throws IOException, LocationNotCreatedExcep new GenericHandler<>(), 1); // routing for passive to receive replication EventHandler replicationEvents = null; - if (configSetupManager.getConfiguration().isRelaySource()) { + if (configSetupManager.isRelaySource()) { replicationEvents = createAndRouteRelayTransactionHandler(replicationResponseStage); } else { ReplicatedTransactionHandler replicatedTransactionHandler = new ReplicatedTransactionHandler(state, replicationResponseStage, this.persistor, entityManager, groupCommManager); sequenceWeight.setReplicatedTransactionHandler(replicatedTransactionHandler); replicationEvents = replicatedTransactionHandler.getEventHandler(); - routeRelayMessages(state, configSetupManager.getConfiguration()); + routeRelayMessages(state, configSetupManager); } // This requires both the stage for handling the replication/sync messages. @@ -854,12 +852,11 @@ connectionPolicy, getOperationGuardian(platformServiceRegistry, } public synchronized void openNetworkPorts() throws ConfigurationException { - Configuration configuration = this.configSetupManager.getConfiguration(); // don't join the group if the configuration is not complete if (this.l2Coordinator == null) { throw new IllegalStateException("server is not bootstrapped"); } - if (!configuration.isPartialConfiguration()) { + if (!configSetupManager.isPartialConfiguration()) { startGroupManagers(); } this.l2Coordinator.start(); @@ -938,7 +935,7 @@ private ConsistencyManager createConsistencyManager(ServerConfigurationManager c return new DiagnosticModeConsistencyManager(); } - boolean consistentStartup = knownPeers > 0 && (configSetupManager.getConfiguration().isConsistentStartup() || voteCount >= 0); + boolean consistentStartup = knownPeers > 0 && (configSetupManager.isConsistentStartup() || voteCount >= 0); return new SafeStartupManagerImpl( consistentStartup, knownPeers, @@ -1179,10 +1176,9 @@ private void startGroupManagers() { throw new IllegalStateException("server is not bootstrapped"); } NodeID myNodeId; - Configuration config = this.configSetupManager.getConfiguration(); - if (config.isRelayDestination()) { - consoleLogger.info("connectiong to {} for duplication", config.getRelayPeer()); - myNodeId = this.groupCommManager.join(this.configSetupManager.getGroupConfiguration().directConnect(config.getRelayPeer())); + if (configSetupManager.isRelayDestination()) { + consoleLogger.info("connectiong to {} for duplication", configSetupManager.getRelayPeer()); + myNodeId = this.groupCommManager.join(this.configSetupManager.getGroupConfiguration().directConnect(configSetupManager.getRelayPeer())); } else { myNodeId = this.groupCommManager.join(this.configSetupManager.getGroupConfiguration()); } @@ -1421,7 +1417,7 @@ public void handleEvent(RelayMessage context) throws EventHandlerException { return handler.getEventHandler(); } - private void routeRelayMessages(StateManager stateMgr, Configuration config) { + private void routeRelayMessages(StateManager stateMgr, ServerConfigurationManager config) { DuplicationTransactionHandler handler = new DuplicationTransactionHandler(stateMgr, n->config.isRelayDestination(), groupCommManager); Stage relays = this.seda.getStageManager().createStage(ServerConfigurationContext.PASSIVE_DUPLICATE_STAGE, RelayMessage.class, handler.getEventHandler(), 1); this.groupCommManager.routeMessages(RelayMessage.class, relays.getSink()); diff --git a/tc-server/src/main/java/com/tc/server/Bootstrap.java b/tc-server/src/main/java/com/tc/server/Bootstrap.java index a279ddd0fb..17889aa9a7 100644 --- a/tc-server/src/main/java/com/tc/server/Bootstrap.java +++ b/tc-server/src/main/java/com/tc/server/Bootstrap.java @@ -276,7 +276,7 @@ public void unpause(String path) { @Override public int getServerCount() { - return config.getConfiguration().getServerConfigurations().size(); + return config.getGroupConfiguration().getNodes().size(); } @Override diff --git a/tc-server/src/main/java/com/tc/services/PlatformConfigurationImpl.java b/tc-server/src/main/java/com/tc/services/PlatformConfigurationImpl.java index 053d01dc56..f6416dd7c4 100644 --- a/tc-server/src/main/java/com/tc/services/PlatformConfigurationImpl.java +++ b/tc-server/src/main/java/com/tc/services/PlatformConfigurationImpl.java @@ -17,43 +17,40 @@ */ package com.tc.services; +import com.tc.config.ServerConfigurationManager; import java.util.Collection; import org.terracotta.entity.PlatformConfiguration; -import org.terracotta.configuration.Configuration; -import org.terracotta.configuration.ServerConfiguration; /** * @author vmad */ public class PlatformConfigurationImpl implements PlatformConfiguration { - private final ServerConfiguration serverConfig; - private final Configuration config; + private final ServerConfigurationManager serverConfig; - public PlatformConfigurationImpl(ServerConfiguration serverConfig, Configuration config) { + public PlatformConfigurationImpl(ServerConfigurationManager serverConfig) { this.serverConfig = serverConfig; - this.config = config; } @Override public String getServerName() { - return serverConfig.getName(); + return serverConfig.getServerConfiguration().getName(); } @Override public String getHost() { - return serverConfig.getHost(); + return serverConfig.getServerConfiguration().getHost(); } @Override public int getTsaPort() { - return serverConfig.getTsaPort().getPort(); + return serverConfig.getServerConfiguration().getTsaPort().getPort(); } @Override public Collection getExtendedConfiguration(Class type) { - return config.getExtendedConfiguration(type); + return serverConfig.getExtendedConfiguration(type); } } diff --git a/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistry.java b/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistry.java index 901622f8bc..232dc6fa0a 100644 --- a/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistry.java +++ b/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistry.java @@ -17,7 +17,7 @@ */ package com.tc.services; -import org.terracotta.configuration.Configuration; +import com.tc.config.ServerConfigurationManager; import org.terracotta.entity.PlatformConfiguration; import org.terracotta.entity.ServiceProvider; @@ -39,7 +39,7 @@ public interface TerracottaServiceProviderRegistry extends PrettyPrintable { * @param loader the classloader used for all services * */ - void initialize(PlatformConfiguration platformConfiguration, Configuration configuration); + void initialize(PlatformConfiguration platformConfiguration, ServerConfigurationManager configuration); /** * Method to register platform level service provider which don't have life-cycle using SPI interface but otherwise act diff --git a/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistryImpl.java b/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistryImpl.java index 48ca0d501d..c7aeb950f6 100644 --- a/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistryImpl.java +++ b/tc-server/src/main/java/com/tc/services/TerracottaServiceProviderRegistryImpl.java @@ -18,6 +18,7 @@ package com.tc.services; import com.tc.classloader.BuiltinService; +import com.tc.config.ServerConfigurationManager; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -28,7 +29,6 @@ import com.tc.util.Assert; import java.io.Closeable; -import org.terracotta.configuration.Configuration; import java.io.PrintWriter; import java.io.StringWriter; @@ -56,7 +56,7 @@ public class TerracottaServiceProviderRegistryImpl implements TerracottaServiceP private boolean hasCreatedSubRegistries; @Override - public void initialize(PlatformConfiguration platformConfiguration, Configuration configuration) { + public void initialize(PlatformConfiguration platformConfiguration, ServerConfigurationManager configuration) { List serviceProviderConfigurationList = configuration.getServiceConfigurations(); Assert.assertFalse(this.hasCreatedSubRegistries); if(serviceProviderConfigurationList != null) {