View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.config.spring;
8   
9   import org.mule.api.MuleContext;
10  import org.mule.api.context.MuleContextAware;
11  import org.mule.api.context.notification.ServerNotificationListener;
12  import org.mule.context.notification.ListenerSubscriptionPair;
13  import org.mule.context.notification.ServerNotificationManager;
14  
15  import java.util.Collection;
16  import java.util.HashSet;
17  import java.util.Map;
18  import java.util.Set;
19  
20  import org.springframework.beans.BeansException;
21  import org.springframework.beans.factory.SmartFactoryBean;
22  import org.springframework.context.ApplicationContext;
23  import org.springframework.context.ApplicationContextAware;
24  
25  public class ServerNotificationManagerConfigurator
26      implements MuleContextAware, SmartFactoryBean, ApplicationContextAware
27  {
28  
29      private MuleContext muleContext;
30      private ApplicationContext applicationContext;
31  
32      private Boolean dynamic;
33      private Map interfaceToEvents;
34      private Collection interfaces;
35      private Collection<ListenerSubscriptionPair> pairs;
36  
37      public void setMuleContext(MuleContext context)
38      {
39          this.muleContext = context;
40      }
41  
42      public Object getObject() throws Exception
43      {
44          ServerNotificationManager notificationManager = muleContext.getNotificationManager();
45          if (dynamic != null)
46          {
47              notificationManager.setNotificationDynamic(dynamic.booleanValue());
48          }
49          if (interfaceToEvents != null)
50          {
51              notificationManager.setInterfaceToTypes(interfaceToEvents);
52          }
53          if (interfaces != null)
54          {
55              notificationManager.setDisabledInterfaces(interfaces);
56          }
57  
58          // Merge:
59          // i) explicitly configured notification listeners,
60          // ii) any singleton beans defined in spring that implement ServerNotificationListener.
61          Set<ListenerSubscriptionPair> subs = getMergedListeners(notificationManager);
62          for (ListenerSubscriptionPair sub : subs)
63          {
64              // Do this to avoid warnings when the Spring context is refreshed
65              if(!notificationManager.isListenerRegistered(sub.getListener()))
66              {
67                  notificationManager.addListenerSubscriptionPair(sub);
68              }
69          }
70          return notificationManager;
71      }
72  
73      protected Set<ListenerSubscriptionPair> getMergedListeners(ServerNotificationManager notificationManager)
74      {
75          Set<ListenerSubscriptionPair> mergedListeners = new HashSet<ListenerSubscriptionPair>();
76  
77          // Any singleton bean defined in spring that implements
78          // ServerNotificationListener or a subclass.
79          String[] listenerBeans = applicationContext.getBeanNamesForType(ServerNotificationListener.class,
80              false, true);
81          Set<ListenerSubscriptionPair> adhocListeners = new HashSet<ListenerSubscriptionPair>();
82          for (String name : listenerBeans)
83          {
84              adhocListeners.add(new ListenerSubscriptionPair(
85                  (ServerNotificationListener<?>) applicationContext.getBean(name), null));
86          }
87  
88          if (pairs != null)
89          {
90              mergedListeners.addAll(pairs);
91  
92              for (ListenerSubscriptionPair candidate : adhocListeners)
93              {
94                  boolean explicityDefined = false;
95                  for (ListenerSubscriptionPair explicitListener : pairs)
96                  {
97                      if (candidate.getListener().equals(explicitListener.getListener()))
98                      {
99                          explicityDefined = true;
100                         break;
101                     }
102                 }
103                 if (!explicityDefined)
104                 {
105                     mergedListeners.add(candidate);
106                 }
107             }
108         }
109         else
110         {
111             mergedListeners.addAll(adhocListeners);
112         }
113 
114         return mergedListeners;
115     }
116 
117     public Class getObjectType()
118     {
119         return ServerNotificationManager.class;
120     }
121 
122     public boolean isSingleton()
123     {
124         return true;
125     }
126 
127     public void setNotificationDynamic(boolean dynamic)
128     {
129         this.dynamic = new Boolean(dynamic);
130     }
131 
132     public void setInterfaceToTypes(Map interfaceToEvents) throws ClassNotFoundException
133     {
134         this.interfaceToEvents = interfaceToEvents;
135     }
136 
137     public void setAllListenerSubscriptionPairs(Collection pairs)
138     {
139         this.pairs = pairs;
140     }
141 
142     public void setDisabledInterfaces(Collection interfaces) throws ClassNotFoundException
143     {
144         this.interfaces = interfaces;
145     }
146 
147     public boolean isEagerInit()
148     {
149         return true;
150     }
151 
152     public boolean isPrototype()
153     {
154         return false;
155     }
156 
157     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
158     {
159         this.applicationContext = applicationContext;
160 
161     }
162 
163 }