http://git-wip-us.apache.org/repos/asf/flex-blazeds/blob/bf2e1dc9/core/src/flex/messaging/config/MessagingConfiguration.java ---------------------------------------------------------------------- diff --git a/core/src/flex/messaging/config/MessagingConfiguration.java b/core/src/flex/messaging/config/MessagingConfiguration.java new file mode 100644 index 0000000..70987a2 --- /dev/null +++ b/core/src/flex/messaging/config/MessagingConfiguration.java @@ -0,0 +1,1001 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package flex.messaging.config; + +import flex.management.ManageableComponent; +import flex.management.runtime.messaging.endpoints.EndpointControl; +import flex.messaging.Destination; +import flex.messaging.FlexComponent; +import flex.messaging.FlexContext; +import flex.messaging.MessageBroker; +import flex.messaging.Server; +import flex.messaging.client.FlexClientManager; +import flex.messaging.cluster.ClusterManager; +import flex.messaging.endpoints.AbstractEndpoint; +import flex.messaging.endpoints.Endpoint; +import flex.messaging.endpoints.Endpoint2; +import flex.messaging.log.Log; +import flex.messaging.log.Target; +import flex.messaging.security.LoginCommand; +import flex.messaging.security.LoginManager; +import flex.messaging.services.AuthenticationService; +import flex.messaging.services.Service; +import flex.messaging.services.ServiceAdapter; +import flex.messaging.util.ClassUtil; +import flex.messaging.util.RedeployManager; +import flex.messaging.util.StringUtils; +import flex.messaging.util.ToStringPrettyPrinter; +import flex.messaging.util.UUIDGenerator; +import flex.messaging.validators.DeserializationValidator; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * This object encapsulates settings for a MessageBroker instance. + * The MessageBroker itself has no knowledge of configuration specifics; + * instead, this object sets the relevant values on the broker using + * information which a ConfigurationParser has provided for it. + * + * + */ +public class MessagingConfiguration implements ServicesConfiguration +{ + private final String asyncMessageBrokerType = "flex.messaging.AsyncMessageBroker"; + private final String asyncFlexClientManagerType = "flex.messaging.client.AsyncFlexClientManager"; + + private final Map<String, ChannelSettings> channelSettings; + private final List<String> defaultChannels; + private final SecuritySettings securitySettings; + private final List<ServiceSettings> serviceSettings; + private final List<SharedServerSettings> sharedServerSettings; + private LoggingSettings loggingSettings; + private SystemSettings systemSettings; + private FlexClientSettings flexClientSettings; + private final Map<String, ClusterSettings> clusterSettings; + private final Map<String, FactorySettings> factorySettings; + private final List<MessageFilterSettings> messageFilterSettings; + private final Map<String, ValidatorSettings> validatorSettings; + + /** + * Constructor. + * Construct a MessagingConfiguration object + * + */ + public MessagingConfiguration() + { + channelSettings = new HashMap<String, ChannelSettings>(); + defaultChannels = new ArrayList<String>(4); + clusterSettings = new HashMap<String, ClusterSettings>(); + factorySettings = new HashMap<String, FactorySettings>(); + serviceSettings = new ArrayList<ServiceSettings>(); + sharedServerSettings = new ArrayList<SharedServerSettings>(); + securitySettings = new SecuritySettings(); + messageFilterSettings = new ArrayList<MessageFilterSettings>(); + validatorSettings = new HashMap<String, ValidatorSettings>(); + } + + /** + * Configure the MessageBroker. + * + * @param broker current MessageBroker object + */ + public void configureBroker(MessageBroker broker) + { + boolean async = (broker.getClass().getName().equals(asyncMessageBrokerType)); + + broker.setChannelSettings(channelSettings); + broker.setSecuritySettings(securitySettings); + broker.setSystemSettings(systemSettings); + broker.setFlexClientSettings(flexClientSettings); + + // validators need to come first so that the other code can use them + createValidators(broker); + + createAuthorizationManager(broker); + createFlexClientManager(broker); + createRedeployManager(broker); + createFactories(broker); + + if (async) + createSharedServers(broker); + + createEndpoints(broker); + // Default channels have to be set after endpoints are created. + broker.setDefaultChannels(defaultChannels); + prepareClusters(broker); + createServices(broker); + + if (async) + createMessageFilters(broker); + + createUUIDGenerator(broker); + } + + /** + * Create a MessageBroker object with the Id. + * + * @param id String the MessageBroker Id + * @param loader the ClassLoader used to load the MessageBroker class + * @return the created MessageBroker object + */ + public MessageBroker createBroker(String id, ClassLoader loader) + { + // Construct MessageBroker with manageable constructor to avoid loading + // any JMX classes in case manageable is set to false. + MessageBroker broker; + try // Use the AsyncMessageBroker, if possible. + { + @SuppressWarnings("unchecked") + Class<? extends MessageBroker> messageBrokerClass = ClassUtil.createClass(asyncMessageBrokerType, loader); + Constructor constructor = messageBrokerClass.getConstructor(boolean.class); + broker = (MessageBroker)constructor.newInstance(systemSettings.isManageable()); + } + catch (Throwable t) // Otherwise, use the default MessageBroker. + { + broker = new MessageBroker(systemSettings.isManageable()); + } + + // Initialize MessageBroker. + broker.setEnforceEndpointValidation(systemSettings.isEnforceEndpointValidation()); + //broker.setManaged(systemSettings.isManageable()); + broker.setId(id); + broker.setClassLoader(loader); + + return broker; + } + + private void createFactories(MessageBroker broker) + { + for (Iterator<Map.Entry<String,FactorySettings>> iter=factorySettings.entrySet().iterator(); iter.hasNext(); ) + { + Map.Entry<String,FactorySettings> entry = iter.next(); + String id = entry.getKey(); + FactorySettings factorySetting = entry.getValue(); + broker.addFactory(id, factorySetting.createFactory(broker.getClassLoader())); + } + } + + private void createFlexClientManager(MessageBroker broker) + { + FlexClientManager flexClientManager = null; + try // Use the async version, if possible. + { + @SuppressWarnings("unchecked") + Class<? extends FlexClientManager> flexClientManagerClass = ClassUtil.createClass(asyncFlexClientManagerType, broker.getClassLoader()); + Constructor ctor = flexClientManagerClass.getConstructor(broker.getClass()); + flexClientManager = (FlexClientManager)ctor.newInstance(broker); + } + catch (Throwable t) // Otherwise, use the default FlexClientManager. + { + flexClientManager = new FlexClientManager(broker.isManaged(), broker); + } + broker.setFlexClientManager(flexClientManager); + } + + private void createRedeployManager(MessageBroker broker) + { + RedeployManager redeployManager = new RedeployManager(); + redeployManager.setEnabled(systemSettings.getRedeployEnabled()); + redeployManager.setWatchInterval(systemSettings.getWatchInterval()); + redeployManager.setTouchFiles(systemSettings.getTouchFiles()); + redeployManager.setWatchFiles(systemSettings.getWatchFiles()); + broker.setRedeployManager(redeployManager); + } + + private void createAuthorizationManager(MessageBroker broker) + { + LoginManager loginManager = new LoginManager(); + + // Create a Login Command for the LoginManager. + LoginCommand loginCommand = null; + + Map loginCommands = securitySettings.getLoginCommands(); + + // If default Login Command is enabled, use it. + LoginCommandSettings loginCommandSettings = (LoginCommandSettings)loginCommands.get(LoginCommandSettings.SERVER_MATCH_OVERRIDE); + if (loginCommandSettings != null) + { + loginCommand = initLoginCommand(loginCommandSettings); + } + // Otherwise, try a server specific Login Command. + else + { + String serverInfo = securitySettings.getServerInfo(); + loginCommandSettings = (LoginCommandSettings)loginCommands.get(serverInfo); + + if (loginCommandSettings != null) + { + loginCommand = initLoginCommand(loginCommandSettings); + } + else + { + // Try a partial match of serverInfo + serverInfo = serverInfo.toLowerCase(); + for (Iterator iterator = loginCommands.keySet().iterator(); iterator.hasNext();) + { + String serverMatch = (String)iterator.next(); + loginCommandSettings = (LoginCommandSettings)loginCommands.get(serverMatch); + + if (serverInfo.indexOf(serverMatch.toLowerCase()) != -1) + { + // add this match for easier lookup next time around + loginCommands.put(serverInfo, loginCommandSettings); + loginCommand = initLoginCommand(loginCommandSettings); + break; + } + } + } + } + + if (loginCommand == null) + { + if (Log.isWarn()) + Log.getLogger(ConfigurationManager.LOG_CATEGORY).warn + ("No login command was found for '" + securitySettings.getServerInfo() + + "'. Please ensure that the login-command tag has the correct server attribute value" + + ", or use 'all' to use the login command regardless of the server."); + } + else + { + loginManager.setLoginCommand(loginCommand); + } + + if (loginCommandSettings != null) + loginManager.setPerClientAuthentication(loginCommandSettings.isPerClientAuthentication()); + + broker.setLoginManager(loginManager); + } + + private LoginCommand initLoginCommand(LoginCommandSettings loginCommandSettings) + { + String loginClass = loginCommandSettings.getClassName(); + Class c = ClassUtil.createClass(loginClass, + FlexContext.getMessageBroker() == null ? null : + FlexContext.getMessageBroker().getClassLoader()); + LoginCommand loginCommand = (LoginCommand)ClassUtil.createDefaultInstance(c, LoginCommand.class); + + return loginCommand; + } + + private void createSharedServers(MessageBroker broker) + { + for (SharedServerSettings settings : sharedServerSettings) + { + String id = settings.getId(); + String className = settings.getClassName(); + Class serverClass = ClassUtil.createClass(className, broker.getClassLoader()); + FlexComponent server = (FlexComponent)ClassUtil.createDefaultInstance(serverClass, serverClass); + server.initialize(id, settings.getProperties()); + if (broker.isManaged() && (server instanceof ManageableComponent)) + { + ManageableComponent manageableServer = (ManageableComponent)server; + manageableServer.setManaged(true); + manageableServer.setParent(broker); + } + + // TODO: move this to only AsyncMessageBroker. + broker.addServer((Server)server); + + if (Log.isInfo()) + { + Log.getLogger(ConfigurationManager.LOG_CATEGORY).info + ("Server '" + id + "' of type '" + className + "' created."); + } + } + } + + private void createEndpoints(MessageBroker broker) + { + for (Iterator<String> iter = channelSettings.keySet().iterator(); iter.hasNext();) + { + String id = iter.next(); + ChannelSettings chanSettings = channelSettings.get(id); + String url = chanSettings.getUri(); + String endpointClassName = chanSettings.getEndpointType(); + + // Create the Endpoint + Endpoint endpoint = broker.createEndpoint(id, url, endpointClassName); + + // Cast to AbstractEndpoint - these are newer properties that post-date the locked Endpoint interface. + if (endpoint instanceof AbstractEndpoint) + { + AbstractEndpoint abstractEndpoint = (AbstractEndpoint)endpoint; + abstractEndpoint.setRemote(chanSettings.isRemote()); + abstractEndpoint.setServerOnly(chanSettings.getServerOnly()); + } + + endpoint.setSecurityConstraint(chanSettings.getConstraint()); + endpoint.setClientType(chanSettings.getClientType()); + + // Assign referenced server + String referencedServerId = chanSettings.getServerId(); + if ((referencedServerId != null) && (endpoint instanceof Endpoint2)) + { + Server server = broker.getServer(referencedServerId); + if (server == null) + { + ConfigurationException ce = new ConfigurationException(); + ce.setMessage(11128, new Object[] {chanSettings.getId(), referencedServerId}); + throw ce; + } + ((Endpoint2)endpoint).setServer(broker.getServer(referencedServerId)); + } + + // Initialize with endpoint properties + endpoint.initialize(id, chanSettings.getProperties()); + + if (Log.isInfo()) + { + String endpointURL = endpoint.getUrl(); + String endpointSecurity = EndpointControl.getSecurityConstraintOf(endpoint); + if (StringUtils.isEmpty(endpointSecurity)) + endpointSecurity = "None"; + Log.getLogger(ConfigurationManager.LOG_CATEGORY).info + ("Endpoint '" + id + "' created with security: " + + endpointSecurity + StringUtils.NEWLINE + + "at URL: " + endpointURL); + } + } + } + + private void createServices(MessageBroker broker) + { + //the broker needs its AuthenticationService always + AuthenticationService authService = new AuthenticationService(); + authService.setMessageBroker(broker); + + for (Iterator<ServiceSettings> iter = serviceSettings.iterator(); iter.hasNext();) + { + ServiceSettings svcSettings = iter.next(); + String svcId = svcSettings.getId(); + String svcClassName = svcSettings.getClassName(); + + // Create the Service + Service service = broker.createService(svcId, svcClassName); + + // Service Class Name - not needed in AbstractService + + // Initialize with service properties + service.initialize(svcId, svcSettings.getProperties()); + + // Default Channels + for (Iterator chanIter = svcSettings.getDefaultChannels().iterator(); chanIter.hasNext();) + { + ChannelSettings chanSettings = (ChannelSettings)chanIter.next(); + service.addDefaultChannel(chanSettings.getId()); + } + + // Adapter Definitions + Map svcAdapterSettings = svcSettings.getAllAdapterSettings(); + for (Iterator asIter = svcAdapterSettings.values().iterator(); asIter.hasNext();) + { + AdapterSettings as = (AdapterSettings) asIter.next(); + service.registerAdapter(as.getId(), as.getClassName()); + if (as.isDefault()) + { + service.setDefaultAdapter(as.getId()); + } + } + + // Destinations + Map destinationSettings = svcSettings.getDestinationSettings(); + for (Iterator destSettingsIter = destinationSettings.keySet().iterator(); destSettingsIter.hasNext();) + { + String destName = (String)destSettingsIter.next(); + DestinationSettings destSettings = (DestinationSettings)destinationSettings.get(destName); + + createDestination(destSettings, service, svcSettings); + } + } + } + + private void createDestination(DestinationSettings destSettings, Service service, ServiceSettings svcSettings) + { + String destId = destSettings.getId(); + Destination destination = service.createDestination(destId); + + // Channels + List chanSettings = destSettings.getChannelSettings(); + if (chanSettings.size() > 0) + { + List<String> channelIds = new ArrayList<String>(2); + for (Iterator iter = chanSettings.iterator(); iter.hasNext();) { + ChannelSettings cs = (ChannelSettings) iter.next(); + channelIds.add(cs.getId()); + } + destination.setChannels(channelIds); + } + + // Security + SecurityConstraint constraint = destSettings.getConstraint(); + destination.setSecurityConstraint(constraint); + + // Initialize with service, adapter and destination properties + destination.initialize(destId, svcSettings.getProperties()); + destination.initialize(destId, destSettings.getAdapterSettings().getProperties()); + destination.initialize(destId, destSettings.getProperties()); + + // Service Adapter + createAdapter(destination, destSettings, svcSettings); + } + + private void createAdapter(Destination destination, DestinationSettings destSettings, ServiceSettings svcSettings) + { + AdapterSettings adapterSettings = destSettings.getAdapterSettings(); + String adapterId = adapterSettings.getId(); + + ServiceAdapter adapter = destination.createAdapter(adapterId); + + // Initialize with service, adapter and then destination properties + adapter.initialize(adapterId, svcSettings.getProperties()); + adapter.initialize(adapterId, adapterSettings.getProperties()); + adapter.initialize(adapterId, destSettings.getProperties()); + + } + + /** + * + * Used by the MessageBrokerServlet to set up the singleton Log instance + * and add any targets defined in the logging configuration. + * This needs to be invoked ahead of creating and bootstrapping a MessageBroker + * instance so we're sure to have the logging system running in case the bootstrap + * process needs to log anything out. + */ + public void createLogAndTargets() + { + if (loggingSettings == null) + { + Log.setPrettyPrinterClass(ToStringPrettyPrinter.class.getName()); + return; + } + + Log.createLog(); + + ConfigMap properties = loggingSettings.getProperties(); + + // Override default pretty printer for FDS to traverse deep Object graphs + if (properties.getPropertyAsString("pretty-printer", null) == null) + { + Log.setPrettyPrinterClass(ToStringPrettyPrinter.class.getName()); + } + + Log.initialize(null, properties); + + // Targets + List targets = loggingSettings.getTargets(); + Iterator it = targets.iterator(); + while (it.hasNext()) + { + TargetSettings targetSettings = (TargetSettings)it.next(); + String className = targetSettings.getClassName(); + + Class c = ClassUtil.createClass(className, + FlexContext.getMessageBroker() == null ? null : + FlexContext.getMessageBroker().getClassLoader()); + try + { + Target target = (Target)c.newInstance(); + target.setLevel(Log.readLevel(targetSettings.getLevel())); + target.setFilters(targetSettings.getFilters()); + target.initialize(null, targetSettings.getProperties()); + Log.addTarget(target); + } + catch (Throwable t) + { + // Unwrap to get to the interesting exception + if (t instanceof InvocationTargetException) + t = t.getCause(); + + System.err.println("*** Error setting up logging system"); + t.printStackTrace(); + + ConfigurationException cx = new ConfigurationException(); + cx.setMessage(10126, new Object[] { className }); + cx.setRootCause(t); + throw cx; + } + } + } + + private void createMessageFilters(MessageBroker broker) + { + Class asyncFilterClass = ClassUtil.createClass("flex.messaging.filters.BaseAsyncMessageFilter"); + Class syncFilterClass = ClassUtil.createClass("flex.messaging.filters.BaseSyncMessageFilter"); + + for (MessageFilterSettings settings : messageFilterSettings) + { + String id = settings.getId(); + String className = settings.getClassName(); + Class filterClass = ClassUtil.createClass(className, broker.getClassLoader()); + FlexComponent filter = (FlexComponent)ClassUtil.createDefaultInstance(filterClass, null); + MessageFilterSettings.FilterType filterType = settings.getFilterType(); + boolean filterIsAsync = filterType == MessageFilterSettings.FilterType.ASYNC; + // Validate filter is assignable to proper base class. + if ((filterIsAsync && !asyncFilterClass.isAssignableFrom(filterClass)) || + (!filterIsAsync && !syncFilterClass.isAssignableFrom(filterClass))) + { + // Filter class is not a valid subclass of either supported base filter type. + ConfigurationException cx = new ConfigurationException(); + int errorCode = filterIsAsync ? 11144 : 11145; + cx.setMessage(errorCode, new Object[] {settings.getId()}); + throw cx; + } + + filter.initialize(id, settings.getProperties()); + if (broker.isManaged() && (filter instanceof ManageableComponent)) + { + ManageableComponent manageableFilter = (ManageableComponent)filter; + manageableFilter.setManaged(true); + manageableFilter.setParent(broker); + } + + try + { + String methodName = filterIsAsync ? "getAsyncMessageFilterChain" : "getSyncMessageFilterChain"; + Method getMessageFilterChain = broker.getClass().getDeclaredMethod(methodName); + Object filterChain = getMessageFilterChain.invoke(broker, (Object[])null); + Class arg = filterIsAsync ? asyncFilterClass : syncFilterClass; + Method addFilter = filterChain.getClass().getDeclaredMethod("add", arg); + addFilter.invoke(filterChain, filter); + } + catch (Exception e) + { + // Hit an unexpected problem adding the filter instance to the broker's async or sync chain. + ConfigurationException cx = new ConfigurationException(); + int errorCode = filterType == MessageFilterSettings.FilterType.ASYNC ? 11138 : 11143; + cx.setMessage(errorCode, new Object[] {settings.getId()}); + cx.setRootCause(e); + throw cx; + } + + if (Log.isInfo()) + { + Log.getLogger(ConfigurationManager.LOG_CATEGORY).info + ("MessageFilter '" + id + "' of type '" + className + "' created."); + } + } + } + + private void createValidators(MessageBroker broker) + { + for (Iterator<ValidatorSettings> iter = validatorSettings.values().iterator(); iter.hasNext(); ) + { + ValidatorSettings settings = iter.next(); + String className = settings.getClassName(); + String type = settings.getType(); + Class<?> validatorClass = ClassUtil.createClass(className, broker.getClassLoader()); + Class<?> expectedClass = ClassUtil.createClass(type, broker.getClassLoader()); + Object validator = ClassUtil.createDefaultInstance(validatorClass, expectedClass); + // Only set the DeserializationValidator types for now. + if (validator instanceof DeserializationValidator) + { + // there can only be one deserialization validator, throw an error if there is more than one. + DeserializationValidator existingValidator = broker.getDeserializationValidator(); + if (existingValidator != null) + { + ConfigurationException cx = new ConfigurationException(); + cx.setMessage(11400, new Object[]{existingValidator.getClass().getCanonicalName(), className}); + throw cx; + } + DeserializationValidator deserializationValidator = (DeserializationValidator)validator; + deserializationValidator.initialize(null, settings.getProperties()); + broker.setDeserializationValidator(deserializationValidator); + if (Log.isInfo()) + { + Log.getLogger(ConfigurationManager.LOG_CATEGORY).info + ("DeserializationValidator of type '" + className + "' created."); + } + } + } + } + + private void createUUIDGenerator(MessageBroker broker) + { + String className = systemSettings.getUUIDGeneratorClassName(); + if (className == null || className.length() == 0) + return; + + Class uuidGeneratorClass = ClassUtil.createClass(className, broker.getClassLoader()); + if (!UUIDGenerator.class.isAssignableFrom(uuidGeneratorClass)) + { + // UUID Generator class is not a valid subclass of ''{0}'' + ConfigurationException cx = new ConfigurationException(); + cx.setMessage(11148, new Object[] {UUIDGenerator.class.getName()}); + throw cx; + } + + Object uuidGenerator = ClassUtil.createDefaultInstance(uuidGeneratorClass, UUIDGenerator.class); + broker.setUUIDGenerator((UUIDGenerator)uuidGenerator); + } + + private void prepareClusters(MessageBroker broker) + { + ClusterManager clusterManager = broker.getClusterManager(); + for (Iterator<String> iter=clusterSettings.keySet().iterator(); iter.hasNext(); ) + { + String clusterId = iter.next(); + ClusterSettings cs = clusterSettings.get(clusterId); + clusterManager.prepareCluster(cs); + } + } + + /** + * Add Shared Server configurations. + * + * @param settings the SharedServerSettings object + **/ + public void addSharedServerSettings(SharedServerSettings settings) + { + sharedServerSettings.add(settings); + } + + /** + * Add the Channel configurations. + * + * @param id the ChannelSetting Id + * @param settings the ChannelSettings + **/ + public void addChannelSettings(String id, ChannelSettings settings) + { + channelSettings.put(id, settings); + } + + /** + * Get the ChannelSettings by Id. + * + * @param id the ChannelSettings Id + * @return ChannelSettings the Channel settings + **/ + public ChannelSettings getChannelSettings(String id) + { + return channelSettings.get(id); + } + + /** + * Get all the ChannelSettings. + * @return Map the Map of all the ChannelSettings, maped by Id + **/ + public Map getAllChannelSettings() + { + return channelSettings; + } + + /** + * Add the default Channel by Id. + * + * @param id the Channel Id + **/ + public void addDefaultChannel(String id) + { + defaultChannels.add(id); + } + + /** + * Get the default Channel List. + * + * @return List, the list of default Channels + **/ + public List getDefaultChannels() + { + return defaultChannels; + } + + /** + * Get the Security Configurations. + * + * @return SecuritySettings current SecuritySettings + **/ + public SecuritySettings getSecuritySettings() + { + return securitySettings; + } + + /** + * Add Service Configurations. + * + * @param settings the ServiceSettings object + **/ + public void addServiceSettings(ServiceSettings settings) + { + serviceSettings.add(settings); + } + + /** + * Get ServiceSettings by Id. + * + * @param id the ServiceSettings Id + * @return ServiceSettings the ServiceSettings object + **/ + public ServiceSettings getServiceSettings(String id) + { + for (Iterator<ServiceSettings> iter = serviceSettings.iterator(); iter.hasNext();) + { + ServiceSettings serviceSettings = iter.next(); + if (serviceSettings.getId().equals(id)) + return serviceSettings; + } + return null; + } + + /** + * Get all ServiceSettings. + * + * @return List all the service settings + **/ + public List getAllServiceSettings() + { + return serviceSettings; + } + + /** + * Get LoggingSettings. + * + * @return LoggingSettings the LoggingSettings object + **/ + public LoggingSettings getLoggingSettings() + { + return loggingSettings; + } + + /** + * Set LoggingSettings. + * + * @param loggingSettings the LoggingSettings object + **/ + public void setLoggingSettings(LoggingSettings loggingSettings) + { + this.loggingSettings = loggingSettings; + } + + /** + * Set SystemSettings. + * + * @param ss the SystemSettings object + **/ + public void setSystemSettings(SystemSettings ss) + { + systemSettings = ss; + } + + /** + * Get SystemSettings. + * + * @return SystemSettings the LoggingSettings object + **/ + public SystemSettings getSystemSettings() + { + return systemSettings; + } + + /** + * Set FlexClientSettings. + * + * @param value the FlexClientSettings object + **/ + public void setFlexClientSettings(FlexClientSettings value) + { + flexClientSettings = value; + } + + /** + * Get FlexClientSettings. + * + * @return FlexClientSettings the FlexClientSettings object + **/ + public FlexClientSettings getFlexClientSettings() + { + return flexClientSettings; + } + + /** + * Add the ClusterSettings. + * + * @param settings the ClusterSettings object + **/ + public void addClusterSettings(ClusterSettings settings) + { + if (settings.isDefault()) + { + for (Iterator<ClusterSettings> it = clusterSettings.values().iterator(); it.hasNext(); ) + { + ClusterSettings cs = it.next(); + + if (cs.isDefault()) + { + ConfigurationException cx = new ConfigurationException(); + cx.setMessage(10214, new Object[] { settings.getClusterName(), cs.getClusterName() }); + throw cx; + } + } + } + if (clusterSettings.containsKey(settings.getClusterName())) + { + ConfigurationException cx = new ConfigurationException(); + cx.setMessage(10206, new Object[] { settings.getClusterName() }); + throw cx; + } + clusterSettings.put(settings.getClusterName(), settings); + } + + /** + * Get the ClusterSettings object by Id. + * + * @param clusterId the ClusterSettings Id + * @return ClusterSettings the ClusterSettings object + **/ + public ClusterSettings getClusterSettings(String clusterId) + { + for (Iterator<ClusterSettings> it = clusterSettings.values().iterator(); it.hasNext(); ) + { + ClusterSettings cs = it.next(); + if (cs.getClusterName() == clusterId) + return cs; // handle null case + if (cs.getClusterName() != null && cs.getClusterName().equals(clusterId)) + return cs; + } + return null; + } + + /** + * Get the default ClusterSettings. + * + * @return ClusterSettings the default ClusterSetting object + **/ + public ClusterSettings getDefaultCluster() + { + for (Iterator<ClusterSettings> it = clusterSettings.values().iterator(); it.hasNext(); ) + { + ClusterSettings cs = it.next(); + if (cs.isDefault()) + return cs; + } + return null; + } + + /** + * Add FactorySettings by Id. + * + * @param id the FactorySettings Id + * @param settings the FactorySettings object + **/ + public void addFactorySettings(String id, FactorySettings settings) + { + factorySettings.put(id, settings); + } + + /** + * Add MessageFilterSettings. + * + * @param settings the MessageFilterSettings object + **/ + public void addMessageFilterSettings(MessageFilterSettings settings) + { + messageFilterSettings.add(settings); + } + + /** + * Add ValidatorSettings. + * + * @param settings the ValidatorSettings object + **/ + public void addValidatorSettings(ValidatorSettings settings) + { + String type = settings.getType(); + if (validatorSettings.containsKey(type)) + { + // Cannot add multiple validators with the same type ''{0}'' + ConfigurationException ce = new ConfigurationException(); + ce.setMessage(11136, new Object[] {type}); + throw ce; + } + validatorSettings.put(type, settings); + } + + /** + * Report unused properties. + * + **/ + public void reportUnusedProperties() + { + ArrayList<Object[]> findings = new ArrayList<Object[]>(); + + Iterator<ServiceSettings> serviceItr = serviceSettings.iterator(); + while (serviceItr.hasNext()) + { + ServiceSettings serviceSettings = serviceItr.next(); + gatherUnusedProperties(serviceSettings.getId(), serviceSettings.getSourceFile(), + ConfigurationConstants.SERVICE_ELEMENT, serviceSettings, findings); + Iterator destinationItr = serviceSettings.getDestinationSettings().values().iterator(); + while (destinationItr.hasNext()) + { + DestinationSettings destinationSettings = (DestinationSettings) destinationItr.next(); + gatherUnusedProperties(destinationSettings.getId(), destinationSettings.getSourceFile(), + ConfigurationConstants.DESTINATION_ELEMENT, + destinationSettings, findings); + + AdapterSettings adapterSettings = destinationSettings.getAdapterSettings(); + if (adapterSettings != null) + { + gatherUnusedProperties(adapterSettings.getId(), adapterSettings.getSourceFile(), + ConfigurationConstants.ADAPTER_ELEMENT, + adapterSettings, findings); + } + } + } + + Iterator<ChannelSettings> channelItr = channelSettings.values().iterator(); + while (channelItr.hasNext()) + { + ChannelSettings channelSettings = channelItr.next(); + // Skip property validation for remote channel-definitions + if (channelSettings.isRemote()) + continue; + + gatherUnusedProperties(channelSettings.getId(), channelSettings.getSourceFile(), + ConfigurationConstants.CHANNEL_ELEMENT, channelSettings, findings); + } + + Iterator<SharedServerSettings> serverItr = sharedServerSettings.iterator(); + while (serverItr.hasNext()) + { + SharedServerSettings serverSettings = serverItr.next(); + gatherUnusedProperties(serverSettings.getId(), serverSettings.getSourceFile(), + ConfigurationConstants.SERVER_ELEMENT, serverSettings, findings); + } + + if (!findings.isEmpty()) + { + int errorNumber = 10149; + ConfigurationException exception = new ConfigurationException(); + StringBuffer allDetails = new StringBuffer(); + for (int i = 0; i < findings.size(); i++) + { + allDetails.append(StringUtils.NEWLINE); + allDetails.append(" "); + exception.setDetails(errorNumber, "pattern", findings.get(i)); + allDetails.append(exception.getDetails()); + exception.setDetails(null); + } + exception.setMessage(errorNumber, new Object[] {allDetails}); + throw exception; + } + } + + private void gatherUnusedProperties + (String settingsId, String settingsSource, String settingsType, + PropertiesSettings settings, Collection<Object[]> result) + { + List unusedProperties = settings.getProperties().findAllUnusedProperties(); + int size = unusedProperties.size(); + if (size > 0) + { + for (int i = 0; i < size; i++) + { + String path = (String) unusedProperties.get(i); + result.add(new Object[] {path, settingsType, settingsId, settingsSource}); + } + } + } +}
http://git-wip-us.apache.org/repos/asf/flex-blazeds/blob/bf2e1dc9/core/src/flex/messaging/config/NetworkSettings.java ---------------------------------------------------------------------- diff --git a/core/src/flex/messaging/config/NetworkSettings.java b/core/src/flex/messaging/config/NetworkSettings.java new file mode 100644 index 0000000..753015c --- /dev/null +++ b/core/src/flex/messaging/config/NetworkSettings.java @@ -0,0 +1,163 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package flex.messaging.config; + +/** + * Network policy settings for a MessageDestination. + */ +public class NetworkSettings +{ + protected String clusterId; + protected ThrottleSettings throttleSettings; + protected int subscriptionTimeoutMinutes; + // This is the more common case so make it the default + protected boolean sharedBackend = true; + private boolean sharedBackendSet = false; + private boolean reliable; + + public static final String NETWORK_ELEMENT = "network"; + public static final String RELIABLE_ELEMENT = "reliable"; + public static final String SUBSCRIPTION_TIMEOUT_MINUTES = "subscription-timeout-minutes"; + public static final String SESSION_TIMEOUT = "session-timeout"; // Deprecated - renamed to subscription-timeout-minutes; retained for legacy config support. + public static final int DEFAULT_TIMEOUT = 0; // Defaults to being invalidated when the associated FlexSession shuts down. + + /** + * Constructs a default <code>NetworkSettings</code> instance with + * default session timeout. + */ + public NetworkSettings() + { + throttleSettings = new ThrottleSettings(); + subscriptionTimeoutMinutes = DEFAULT_TIMEOUT; + } + + /** + * Returns the cluster id. + * + * @return The cluster id. + */ + public String getClusterId() + { + return clusterId; + } + + /** + * Sets the cluster id. + * + * @param id The cluster id. + */ + public void setClusterId(String id) + { + this.clusterId = id; + } + + /** + * Returns the <code>reliable</code> setting. + * + * @return The <code>reliable</code> setting. + */ + public boolean isReliable() + { + return reliable; + } + + /** + * Sets the <code>reliable</code> setting. + * + * @param value The value to set the <code>reliable</code> setting to. + */ + public void setReliable(boolean value) + { + reliable = value; + } + + /** + * Returns the <code>subscription-timeout-minutes</code> property. + * + * @return the <code>subscription-timeout-minutes</code> property. + */ + public int getSubscriptionTimeoutMinutes() + { + return subscriptionTimeoutMinutes; + } + + /** + * Sets the <code>subscription-timeout-minutes</code> property which is the idle time in + * minutes before a subscriber that no messages are being pushed to will be unsubscribed. + * A value of 0 will cause subscriptions to be kept alive as long as the associated FlexSession + * they are created over is active. + * + * @param value The value to set the <code>subscription-timeout-minutes</code> property to. + */ + public void setSubscriptionTimeoutMinutes(int value) + { + subscriptionTimeoutMinutes = value; + } + + /** + * Returns the <code>shared-backend</code> property. + * + * @return the <code>shared-backend</code> property. + */ + public boolean isSharedBackend() + { + return sharedBackend; + } + + /** + * Sets the <code>shared-backend</code> property. + * + * @param sharedBackend The value to set the <code>shared-backend</code> property to. + */ + public void setSharedBackend(boolean sharedBackend) + { + this.sharedBackend = sharedBackend; + this.sharedBackendSet = true; + } + + /** + * Returns true if the shared backend has been set or false if it is + * still using the default. + * + * @return <code>true</code> if the shared backend has been set; <code>false</code> otherwise. + */ + public boolean isSharedBackendSet() + { + return sharedBackendSet; + } + + /** + * Returns the <code>ThrottleSettings</code> property. + * + * @return the <code>ThrottleSettings</code> property. + */ + public ThrottleSettings getThrottleSettings() + { + return throttleSettings; + } + + /** + * Sets the <code>ThrottleSettings</code> property. + * + * @param value The value to set the <code>ThrottleSettings</code> property to. + */ + public void setThrottleSettings(ThrottleSettings value) + { + throttleSettings = value; + } + +} http://git-wip-us.apache.org/repos/asf/flex-blazeds/blob/bf2e1dc9/core/src/flex/messaging/config/SecuritySettings.java ---------------------------------------------------------------------- diff --git a/core/src/flex/messaging/config/SecuritySettings.java b/core/src/flex/messaging/config/SecuritySettings.java new file mode 100644 index 0000000..f95412a --- /dev/null +++ b/core/src/flex/messaging/config/SecuritySettings.java @@ -0,0 +1,103 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package flex.messaging.config; + +import flex.messaging.security.SecurityException; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * + */ +public class SecuritySettings +{ + // Exception/error message numbers. + private static final int NO_SEC_CONSTRAINT = 10062; + + private String serverInfo; + private Map loginCommandSettings; + private Map constraints; + private boolean recreateHttpSessionAfterLogin; + + public SecuritySettings() + { + constraints = new HashMap(); + loginCommandSettings = new HashMap(); + } + + public void addConstraint(SecurityConstraint sc) + { + constraints.put(sc.getId(), sc); + } + + public SecurityConstraint getConstraint(String ref) + { + // If an attempt is made to use a constraint that we do not know about, + // do not let the authorization succeed + if (constraints.get(ref) == null) + { + // Security constraint {0} is not defined. + SecurityException se = new SecurityException(); + se.setMessage(NO_SEC_CONSTRAINT, new Object[] {ref}); + throw se; + } + return (SecurityConstraint)constraints.get(ref); + } + + public void addLoginCommandSettings(LoginCommandSettings lcs) + { + loginCommandSettings.put(lcs.getServer(), lcs); + } + + public Map getLoginCommands() + { + return loginCommandSettings; + } + + /** + * Returns a read-only set of constraints. + * + * @return the set of security constraints + */ + public Collection<SecurityConstraint> getConstraints() + { + return Collections.unmodifiableCollection(constraints.values()); + } + + public void setServerInfo(String s) + { + serverInfo = s; + } + + public String getServerInfo() + { + return serverInfo; + } + + public boolean isRecreateHttpSessionAfterLogin() + { + return recreateHttpSessionAfterLogin; + } + + public void setRecreateHttpSessionAfterLogin(boolean value) + { + recreateHttpSessionAfterLogin = value; + } +}
