001/**
002 *   GRANITE DATA SERVICES
003 *   Copyright (C) 2006-2013 GRANITE DATA SERVICES S.A.S.
004 *
005 *   This file is part of the Granite Data Services Platform.
006 *
007 *   Granite Data Services is free software; you can redistribute it and/or
008 *   modify it under the terms of the GNU Lesser General Public
009 *   License as published by the Free Software Foundation; either
010 *   version 2.1 of the License, or (at your option) any later version.
011 *
012 *   Granite Data Services is distributed in the hope that it will be useful,
013 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
014 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
015 *   General Public License for more details.
016 *
017 *   You should have received a copy of the GNU Lesser General Public
018 *   License along with this library; if not, write to the Free Software
019 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
020 *   USA, or see <http://www.gnu.org/licenses/>.
021 */
022package org.granite.config.servlet3;
023
024import java.io.InputStream;
025import java.lang.annotation.Annotation;
026import java.lang.reflect.Field;
027import java.lang.reflect.Method;
028import java.math.BigDecimal;
029import java.math.BigInteger;
030import java.util.ArrayList;
031import java.util.Arrays;
032import java.util.HashMap;
033import java.util.HashSet;
034import java.util.List;
035import java.util.Set;
036
037import javax.servlet.FilterRegistration;
038import javax.servlet.Servlet;
039import javax.servlet.ServletContainerInitializer;
040import javax.servlet.ServletContext;
041import javax.servlet.ServletException;
042import javax.servlet.ServletRegistration;
043import javax.servlet.annotation.HandlesTypes;
044
045import org.granite.config.ConfigProvider;
046import org.granite.config.GraniteConfig;
047import org.granite.config.GraniteConfigListener;
048import org.granite.config.GraniteConfigListener.ServiceConfigurator;
049import org.granite.config.ServletGraniteConfig;
050import org.granite.config.flex.Channel;
051import org.granite.config.flex.Destination;
052import org.granite.config.flex.EndPoint;
053import org.granite.config.flex.Factory;
054import org.granite.config.flex.Service;
055import org.granite.config.flex.ServicesConfig;
056import org.granite.config.flex.ServletServicesConfig;
057import org.granite.gravity.GravityManager.GravityServiceConfigurator;
058import org.granite.gravity.config.AbstractActiveMQTopicDestination;
059import org.granite.gravity.config.AbstractJmsTopicDestination;
060import org.granite.gravity.config.AbstractMessagingDestination;
061import org.granite.gravity.config.servlet3.ActiveMQTopicDestination;
062import org.granite.gravity.config.servlet3.JmsTopicDestination;
063import org.granite.gravity.config.servlet3.MessagingDestination;
064import org.granite.gravity.security.GravityDestinationSecurizer;
065import org.granite.logging.Logger;
066import org.granite.messaging.amf.io.util.externalizer.BigDecimalExternalizer;
067import org.granite.messaging.amf.io.util.externalizer.BigIntegerExternalizer;
068import org.granite.messaging.amf.io.util.externalizer.Externalizer;
069import org.granite.messaging.amf.io.util.externalizer.LongExternalizer;
070import org.granite.messaging.amf.process.AMF3MessageInterceptor;
071import org.granite.messaging.service.ExceptionConverter;
072import org.granite.messaging.service.ServiceFactory;
073import org.granite.messaging.service.SimpleServiceFactory;
074import org.granite.messaging.service.security.RemotingDestinationSecurizer;
075import org.granite.messaging.service.security.SecurityService;
076import org.granite.messaging.service.tide.TideComponentAnnotatedWithMatcher;
077import org.granite.messaging.service.tide.TideComponentInstanceOfMatcher;
078import org.granite.messaging.service.tide.TideComponentNameMatcher;
079import org.granite.messaging.service.tide.TideComponentTypeMatcher;
080import org.granite.messaging.webapp.AMFMessageFilter;
081import org.granite.messaging.webapp.AMFMessageServlet;
082import org.granite.util.TypeUtil;
083import org.granite.util.XMap;
084
085/**
086 * @author William DRAI
087 */
088@HandlesTypes({ServerFilter.class})
089public class GraniteServlet3Initializer implements ServletContainerInitializer {
090
091        public void onStartup(Set<Class<?>> scannedClasses, ServletContext servletContext) throws ServletException {
092                Set<Class<?>> classes = new HashSet<Class<?>>();
093                if (scannedClasses != null) {
094                        classes.addAll(scannedClasses);
095                        classes.remove(ServerFilter.class);     // JBossWeb adds the annotation ???
096                }
097                if (classes.size() > 1)
098                        throw new ServletException("Application must have only one ServerFilter configuration class");
099                
100                if (!classes.isEmpty()) {
101                        // Configure GraniteDS only if we find a config class annotated with @ServerFilter
102                        Class<?> clazz = classes.iterator().next();
103                        ServerFilter serverFilter = clazz.getAnnotation(ServerFilter.class);
104                        
105                        servletContext.setAttribute(GraniteConfigListener.GRANITE_CONFIG_ATTRIBUTE, new Servlet3ServiceConfigurator(clazz));
106                        
107                    servletContext.addListener(new GraniteConfigListener());
108                        
109                        if (servletContext.getFilterRegistration("AMFMessageFilter") == null) {
110                                FilterRegistration.Dynamic graniteFilter = servletContext.addFilter("AMFMessageFilter", AMFMessageFilter.class);
111                                graniteFilter.addMappingForUrlPatterns(null, true, serverFilter.graniteUrlMapping());
112                        }
113                        if (servletContext.getServletRegistration("AMFMessageServlet") == null) {
114                                ServletRegistration.Dynamic graniteServlet = servletContext.addServlet("AMFMessageServlet", AMFMessageServlet.class);
115                                graniteServlet.setLoadOnStartup(1);
116                                graniteServlet.addMapping(serverFilter.graniteUrlMapping());
117                        }
118                        
119                        try {
120                                if (servletContext.getServletRegistration("GravityServlet") == null) {
121                                        Class<? extends Servlet> gravityAsyncServletClass = TypeUtil.forName("org.granite.gravity.servlet3.GravityAsyncServlet", Servlet.class);
122                                        ServletRegistration.Dynamic gravityServlet = servletContext.addServlet("GravityServlet", gravityAsyncServletClass);
123                                        gravityServlet.setLoadOnStartup(1);
124                                        gravityServlet.setAsyncSupported(true);
125                                        gravityServlet.addMapping(serverFilter.gravityUrlMapping());
126                                }
127                        }
128                        catch (ClassNotFoundException e) {
129                                servletContext.log("Could not setup GravityAsyncServlet", e);
130                        }
131
132//            if (servletContext.getServletRegistration("WebSocketServlet") == null) {
133//                try {
134//                    TypeUtil.forName("javax.websocket.server.ServerEndpointConfig");
135//                    try {
136//                        servletContext.addListener(TypeUtil.forName("org.granite.gravity.servlet3.websocket.GravityWebSocketDeployer", ServletContextListener.class));
137//                    }
138//                    catch (ClassNotFoundException f) {
139//                        servletContext.log("Could not setup WebSocket deployer", f);
140//                    }
141//                }
142//                catch (ClassNotFoundException e) {
143//                    // No JSR 356 websocket support detected
144//                }
145//            }
146                }
147        }
148        
149        
150        public static class Servlet3ServiceConfigurator implements ServiceConfigurator, GravityServiceConfigurator {
151                
152                private static final Logger log = Logger.getLogger(Servlet3ServiceConfigurator.class);
153                
154                private final Class<?> serverFilterClass;
155                
156                public Servlet3ServiceConfigurator(Class<?> serverFilterClass) {
157                        this.serverFilterClass = serverFilterClass;
158                }
159                
160                public void initialize(ServletContext servletContext) {
161                        servletContext.setAttribute(ServletGraniteConfig.GRANITE_CONFIG_DEFAULT_KEY, "org/granite/config/servlet3/granite-config-servlet3.xml");
162                }
163                
164            public void configureServices(ServletContext servletContext) throws ServletException {
165                GraniteConfig graniteConfig = ServletGraniteConfig.loadConfig(servletContext);
166                ServicesConfig servicesConfig = ServletServicesConfig.loadConfig(servletContext, true);
167                
168                ServerFilter serverFilter = serverFilterClass.getAnnotation(ServerFilter.class);
169                
170                ConfigProvider configProvider = null;
171                
172                boolean useTide = serverFilter.tide();
173                String type = serverFilter.type();
174                Class<?> factoryClass = null;
175                Set<Class<?>> tideInterfaces = new HashSet<Class<?>>(Arrays.asList(serverFilter.tideInterfaces()));
176                Set<Class<? extends Annotation>> tideAnnotations = new HashSet<Class<? extends Annotation>>(Arrays.asList(serverFilter.tideAnnotations()));
177                
178                if (!serverFilter.configProviderClass().equals(ConfigProvider.class)) {
179                        try {
180                                configProvider = TypeUtil.newInstance(serverFilter.configProviderClass(), new Class[] { ServletContext.class }, new Object[] { servletContext });
181                                
182                                servletContext.setAttribute(GraniteConfigListener.GRANITE_CONFIG_PROVIDER_ATTRIBUTE, configProvider);
183                                
184                                if (configProvider.useTide() != null)
185                                        useTide = configProvider.useTide();
186                                
187                                if (configProvider.getType() != null)
188                                        type = configProvider.getType();
189                                
190                                factoryClass = configProvider.getFactoryClass();
191                                
192                                if (configProvider.getTideInterfaces() != null)
193                                        tideInterfaces.addAll(Arrays.asList(configProvider.getTideInterfaces()));
194                                
195                                if (configProvider.getTideAnnotations() != null)
196                                        tideAnnotations.addAll(Arrays.asList(configProvider.getTideAnnotations()));
197                                }
198                                catch (Exception e) {
199                                        log.error(e, "Could not set config provider of type %s", serverFilter.configProviderClass().getName());
200                                }
201                }
202                
203                if (!serverFilter.factoryClass().equals(ServiceFactory.class))
204                        factoryClass = serverFilter.factoryClass();
205            else if (!serverFilter.factoryClassName().equals("")) {
206                try {
207                    factoryClass = TypeUtil.forName(serverFilter.factoryClassName(), ServiceFactory.class);
208                }
209                catch (ClassNotFoundException e) {
210                    throw new ServletException("Could not find service factory class " + serverFilter.factoryClassName(), e);
211                }
212            }
213                
214                if (factoryClass == null)
215                        factoryClass = useTide ? org.granite.tide.simple.SimpleServiceFactory.class : SimpleServiceFactory.class;
216
217                for (Class<?> ti : tideInterfaces) {
218                        try {
219                                graniteConfig.getTideComponentMatchers().add(new TideComponentInstanceOfMatcher(ti.getName(), false));
220                                log.debug("Enabled components implementing %s for Tide remoting", ti);
221                        }
222                        catch (Exception e) {
223                                log.error(e, "Could not add tide-component interface %s", ti);
224                        }
225                }
226                for (Class<? extends Annotation> ta : tideAnnotations) {
227                        try {
228                                graniteConfig.getTideComponentMatchers().add(new TideComponentAnnotatedWithMatcher(ta.getName(), false));
229                                log.debug("Enabled components annotated with %s for Tide remoting", ta);
230                        }
231                        catch (Exception e) {
232                                log.error(e, "Could not add tide-component annotation %s", ta);
233                        }
234                }
235                for (String tn : serverFilter.tideNames()) {
236                        try {
237                                graniteConfig.getTideComponentMatchers().add(new TideComponentNameMatcher(tn, false));
238                                log.debug("Enabled components with name %s for Tide remoting", tn);
239                        }
240                        catch (Exception e) {
241                                log.error(e, "Could not add tide-component name %s", tn);
242                        }
243                }
244                for (String tt : serverFilter.tideTypes()) {
245                        try {
246                                graniteConfig.getTideComponentMatchers().add(new TideComponentTypeMatcher(tt, false));
247                                log.debug("Enabled components with type %s for Tide remoting", tt);
248                        }
249                        catch (Exception e) {
250                                log.error(e, "Could not add tide-component type %s", tt);
251                        }
252                }
253                
254                for (Class<? extends ExceptionConverter> ec : serverFilter.exceptionConverters()) {
255                        graniteConfig.registerExceptionConverter(ec, true);
256                                log.debug("Registered exception converter %s", ec);
257                }
258                if (configProvider != null) {
259                        for (ExceptionConverter ec : configProvider.findInstances(ExceptionConverter.class)) {
260                                graniteConfig.registerExceptionConverter(ec, true);
261                                log.debug("Registered exception converter %s", ec.getClass());
262                        }
263                }
264
265            if (configProvider != null) {
266                for (Externalizer ext : configProvider.findInstances(Externalizer.class)) {
267                    graniteConfig.registerExternalizer(ext);
268                    log.debug("Registered externalizer %s", ext.getClass());
269                }
270            }
271
272                if (serverFilter.useBigDecimal())
273                        graniteConfig.setExternalizersByType(BigDecimal.class.getName(), BigDecimalExternalizer.class.getName());
274                
275                if (serverFilter.useBigInteger())
276                        graniteConfig.setExternalizersByType(BigInteger.class.getName(), BigIntegerExternalizer.class.getName());
277                
278                if (serverFilter.useLong())
279                        graniteConfig.setExternalizersByType(Long.class.getName(), LongExternalizer.class.getName());
280                
281                if (!serverFilter.securityServiceClass().equals(SecurityService.class)) {
282                        try {
283                                graniteConfig.setSecurityService(TypeUtil.newInstance(serverFilter.securityServiceClass(), SecurityService.class));
284                        }
285                        catch (Exception e) {
286                                throw new ServletException("Could not setup security service", e);
287                        }
288                }
289                else if (graniteConfig.getSecurityService() == null && configProvider != null) {
290                                SecurityService securityService = configProvider.findInstance(SecurityService.class);
291                                graniteConfig.setSecurityService(securityService);
292                        }
293                if (graniteConfig.getSecurityService() == null) {
294                        String securityServiceClassName = null;
295                        // Try auto-detect
296                        try {
297                                TypeUtil.forName("org.mortbay.jetty.Request");
298                                securityServiceClassName = "org.granite.messaging.service.security.Jetty6SecurityService";
299                        }
300                        catch (ClassNotFoundException e1) {
301                                try {
302                                        TypeUtil.forName("org.eclipse.jetty.server.Request");
303                                        securityServiceClassName = "org.granite.messaging.service.security.Jetty7SecurityService";
304                                }
305                                catch (ClassNotFoundException e1b) {
306                                        try {
307                                                TypeUtil.forName("weblogic.servlet.security.ServletAuthentication");
308                                                securityServiceClassName = "org.granite.messaging.service.security.WebLogicSecurityService";
309                                        }
310                                        catch (ClassNotFoundException e2) {
311                                                try {
312                                                        TypeUtil.forName("com.sun.appserv.server.LifecycleEvent");
313                                                securityServiceClassName = "org.granite.messaging.service.security.GlassFishV3SecurityService";
314                                                }
315                                                catch (ClassNotFoundException e3) {
316                                try {
317                                    TypeUtil.forName("io.undertow.server.HttpServerExchange");
318                                    securityServiceClassName = "org.granite.messaging.service.security.UndertowSecurityService";
319                                }
320                                catch (ClassNotFoundException e4) {
321                                    try {
322                                        TypeUtil.forName("org.apache.catalina.connector.Request");
323                                                                securityServiceClassName = "org.granite.messaging.service.security.Tomcat7SecurityService";
324                                    }
325                                    catch (ClassNotFoundException e5) {
326                                        log.warn(e5, "No suitable security service implementation could be detected");
327                                    }
328                                }
329                                                }
330                                        }
331                                        try {
332                            if (securityServiceClassName != null)
333                                                    graniteConfig.setSecurityService((SecurityService)TypeUtil.newInstance(securityServiceClassName));
334                                }
335                                catch (Exception e) {
336                                        log.error(e, "Could not setup security service " + securityServiceClassName);
337                                }
338                                }
339                        }
340                }
341                
342                if (!serverFilter.amf3MessageInterceptor().equals(AMF3MessageInterceptor.class)) {
343                        try {
344                                graniteConfig.setAmf3MessageInterceptor(TypeUtil.newInstance(serverFilter.amf3MessageInterceptor(), AMF3MessageInterceptor.class));
345                        }
346                        catch (Exception e) {
347                                throw new ServletException("Could not setup amf3 message interceptor", e);
348                        }
349                }
350                else if (graniteConfig.getAmf3MessageInterceptor() == null && configProvider != null) {
351                        AMF3MessageInterceptor amf3MessageInterceptor = configProvider.findInstance(AMF3MessageInterceptor.class);
352                                graniteConfig.setAmf3MessageInterceptor(amf3MessageInterceptor);
353                }
354                
355                Channel channel = servicesConfig.findChannelById("graniteamf");
356                if (channel == null) {
357                        channel = new Channel("graniteamf", "mx.messaging.channels.AMFChannel", 
358                                new EndPoint("http://{server.name}:{server.port}/{context.root}/graniteamf/amf", "flex.messaging.endpoints.AMFEndpoint"), 
359                                new XMap());
360                        servicesConfig.addChannel(channel);
361                }
362
363                XMap factoryProperties = new XMap();
364                String lookup = null;
365                if (useTide) {
366                        lookup = "java:global/{context.root}/{capitalized.component.name}Bean";
367                        if (isJBoss6())
368                                lookup = "{capitalized.component.name}Bean/local";
369                        if (!("".equals(serverFilter.ejbLookup())))
370                                lookup = serverFilter.ejbLookup();
371                }
372                else {
373                        lookup = "java:global/{context.root}/{capitalized.destination.id}Bean";
374                        if (isJBoss6())
375                                lookup = "{capitalized.destination.id}Bean/local";
376                        if (!("".equals(serverFilter.ejbLookup())))
377                                lookup = serverFilter.ejbLookup();
378                }
379                if (lookup.indexOf("{context.root}") >= 0) {
380                        try {
381                                // Call by reflection because of JDK 1.4
382                                Method m = servletContext.getClass().getMethod("getContextPath");
383                    m.setAccessible(true);
384                                String contextPath = (String)m.invoke(servletContext);
385                                lookup = lookup.replace("{context.root}", contextPath.substring(1));
386                        }
387                        catch (Exception e) {
388                                log.error(e, "Could not get context path, please define lookup manually in @ServerFilter");
389                        }
390                }
391                factoryProperties.put("lookup", lookup);
392
393                if (useTide) {
394                        Factory factory = servicesConfig.findFactoryById("tide-" + type + "-factory");
395                        if (factory == null) {
396                                factory = new Factory("tide-" + type + "-factory", factoryClass.getName(), factoryProperties);
397                                servicesConfig.addFactory(factory);
398                        }
399                        
400                        Service service = servicesConfig.findServiceById("granite-service");
401                        if (service == null) {
402                                service = new Service("granite-service", "flex.messaging.services.RemotingService", 
403                                                "flex.messaging.messages.RemotingMessage", null, null, new HashMap<String, Destination>());
404                                List<String> channelIds = new ArrayList<String>();
405                                channelIds.add("graniteamf");
406                                List<String> tideRoles = serverFilter.tideRoles().length == 0 ? null : Arrays.asList(serverFilter.tideRoles());
407                                Destination destination = new Destination(type, channelIds, new XMap(), tideRoles, null, null);
408                                destination.getProperties().put("factory", "tide-" + type + "-factory");
409                                if (!("".equals(serverFilter.entityManagerFactoryJndiName())))
410                                        destination.getProperties().put("entity-manager-factory-jndi-name", serverFilter.entityManagerFactoryJndiName());
411                                else if (!("".equals(serverFilter.entityManagerJndiName())))
412                                        destination.getProperties().put("entity-manager-jndi-name", serverFilter.entityManagerJndiName());
413                                if (!("".equals(serverFilter.validatorClassName())))
414                                        destination.getProperties().put("validator-class-name", serverFilter.validatorClassName());
415                                service.getDestinations().put(type, destination);
416                                
417                                if (destination.getSecurizer() == null && configProvider != null) {
418                                RemotingDestinationSecurizer securizer = configProvider.findInstance(RemotingDestinationSecurizer.class);
419                                destination.setSecurizer(securizer);
420                                }
421                                
422                                servicesConfig.addService(service);
423                        }
424                    
425                        if (factoryClass.getName().equals("org.granite.tide.ejb.EjbServiceFactory") || factoryClass.getName().equals("org.granite.tide.simple.SimpleServiceFactory"))
426                                servicesConfig.scan(null);
427                        
428                        log.info("Registered Tide " + factoryClass + " service factory and " + type + " destination");
429                }
430                else {
431                        Factory factory = new Factory(type + "-factory", factoryClass.getName(), factoryProperties);
432                        servicesConfig.addFactory(factory);
433                        
434                        Service service = new Service("granite-service", "flex.messaging.services.RemotingService", 
435                                "flex.messaging.messages.RemotingMessage", null, null, new HashMap<String, Destination>());
436                        servicesConfig.addService(service);
437                    
438                    servicesConfig.scan(null);
439                        
440                        log.info("Registered " + factoryClass + " service factory");
441                }
442            }
443            
444                private static boolean isJBoss6() {
445                        try {
446                                InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("/org/jboss/version.properties");
447                                if (is != null)
448                                        return true;
449                        }
450                        catch (Throwable t) {
451                        }
452                        return false;
453                }               
454            
455            private static void initSecurizer(AbstractMessagingDestination messagingDestination, Class<? extends GravityDestinationSecurizer> securizerClass, ConfigProvider configProvider) {
456                        if (securizerClass != GravityDestinationSecurizer.class) {
457                                if (configProvider != null)
458                                        messagingDestination.setSecurizer(configProvider.findInstance(securizerClass));
459                                if (messagingDestination.getSecurizer() == null)
460                                        messagingDestination.setSecurizerClassName(securizerClass.getName());
461                        }
462            }
463
464                
465                public void configureGravityServices(ServletContext servletContext) throws ServletException {
466                ServicesConfig servicesConfig = ServletServicesConfig.loadConfig(servletContext);
467                
468                ConfigProvider configProvider = (ConfigProvider)servletContext.getAttribute(GraniteConfigListener.GRANITE_CONFIG_PROVIDER_ATTRIBUTE);
469                
470                for (Field field : serverFilterClass.getDeclaredFields()) {
471                        if (field.isAnnotationPresent(MessagingDestination.class)) {
472                                MessagingDestination md = field.getAnnotation(MessagingDestination.class);
473                                AbstractMessagingDestination messagingDestination = new AbstractMessagingDestination();
474                                messagingDestination.setId(field.getName());
475                                messagingDestination.setNoLocal(md.noLocal());
476                                messagingDestination.setSessionSelector(md.sessionSelector());
477                    if (md.securityRoles().length > 0)
478                        messagingDestination.setRoles(Arrays.asList(md.securityRoles()));
479                                initSecurizer(messagingDestination, md.securizer(), configProvider);
480                                messagingDestination.initServices(servicesConfig);
481                        }
482                        else if (field.isAnnotationPresent(JmsTopicDestination.class)) {
483                                JmsTopicDestination md = field.getAnnotation(JmsTopicDestination.class);
484                                AbstractJmsTopicDestination messagingDestination = new AbstractJmsTopicDestination();
485                                messagingDestination.setId(field.getName());
486                                messagingDestination.setNoLocal(md.noLocal());
487                                messagingDestination.setSessionSelector(md.sessionSelector());
488                    if (md.securityRoles().length > 0)
489                        messagingDestination.setRoles(Arrays.asList(md.securityRoles()));
490                                initSecurizer(messagingDestination, md.securizer(), configProvider);
491                                messagingDestination.initServices(servicesConfig);
492                                messagingDestination.setName(md.name());
493                                messagingDestination.setTextMessages(md.textMessages());
494                                messagingDestination.setAcknowledgeMode(md.acknowledgeMode());
495                                messagingDestination.setConnectionFactory(md.connectionFactory());
496                                messagingDestination.setTransactedSessions(md.transactedSessions());
497                                messagingDestination.setJndiName(md.topicJndiName());
498                                messagingDestination.initServices(servicesConfig);
499                        }
500                        else if (field.isAnnotationPresent(ActiveMQTopicDestination.class)) {
501                                ActiveMQTopicDestination md = field.getAnnotation(ActiveMQTopicDestination.class);
502                                AbstractActiveMQTopicDestination messagingDestination = new AbstractActiveMQTopicDestination();
503                                messagingDestination.setId(field.getName());
504                                messagingDestination.setNoLocal(md.noLocal());
505                                messagingDestination.setSessionSelector(md.sessionSelector());
506                    if (md.securityRoles().length > 0)
507                        messagingDestination.setRoles(Arrays.asList(md.securityRoles()));
508                                initSecurizer(messagingDestination, md.securizer(), configProvider);
509                                messagingDestination.initServices(servicesConfig);
510                                messagingDestination.setName(md.name());
511                                messagingDestination.setTextMessages(md.textMessages());
512                                messagingDestination.setAcknowledgeMode(md.acknowledgeMode());
513                                messagingDestination.setConnectionFactory(md.connectionFactory());
514                                messagingDestination.setTransactedSessions(md.transactedSessions());
515                                messagingDestination.setJndiName(md.topicJndiName());
516                                messagingDestination.setBrokerUrl(md.brokerUrl());
517                                messagingDestination.setCreateBroker(md.createBroker());
518                                messagingDestination.setDurable(md.durable());
519                                messagingDestination.setWaitForStart(md.waitForStart());
520                                messagingDestination.setFileStoreRoot(md.fileStoreRoot());
521                                messagingDestination.initServices(servicesConfig);
522                        }
523                }
524                }
525        }
526}