1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.jetty.osgi.boot.internal.webapp;
20
21
22 import java.util.ArrayList;
23 import java.util.Collection;
24 import java.util.HashMap;
25 import java.util.Iterator;
26 import java.util.Map;
27 import java.util.Map.Entry;
28
29 import org.eclipse.jetty.osgi.boot.BundleProvider;
30 import org.eclipse.jetty.osgi.boot.OSGiServerConstants;
31 import org.eclipse.jetty.osgi.boot.utils.TldBundleDiscoverer;
32 import org.eclipse.jetty.util.log.Log;
33 import org.eclipse.jetty.util.log.Logger;
34 import org.osgi.framework.Bundle;
35 import org.osgi.framework.BundleEvent;
36 import org.osgi.framework.FrameworkUtil;
37 import org.osgi.framework.ServiceReference;
38 import org.osgi.util.tracker.BundleTracker;
39 import org.osgi.util.tracker.BundleTrackerCustomizer;
40 import org.osgi.util.tracker.ServiceTracker;
41
42
43
44
45
46
47
48
49 public class BundleWatcher implements BundleTrackerCustomizer
50 {
51 private static final Logger LOG = Log.getLogger(BundleWatcher.class);
52
53 public static final Collection<TldBundleDiscoverer> JSP_REGISTRATION_HELPERS = new ArrayList<TldBundleDiscoverer>();
54
55
56 public static final String FILTER = "(objectclass=" + BundleProvider.class.getName() + ")";
57 private ServiceTracker _serviceTracker;
58 private BundleTracker _bundleTracker;
59 private boolean _waitForDefaultServer = true;
60 private boolean _defaultServerReady = false;
61 private Bundle _bundle = null;
62
63
64
65
66 public BundleWatcher() throws Exception
67 {
68 _bundle = FrameworkUtil.getBundle(this.getClass());
69
70 _serviceTracker = new ServiceTracker(_bundle.getBundleContext(), FrameworkUtil.createFilter(FILTER),null);
71 _serviceTracker.open();
72 }
73
74
75
76 public boolean isWaitForDefaultServer()
77 {
78 return _waitForDefaultServer;
79 }
80
81
82
83 public void setWaitForDefaultServer(boolean waitForDefaultServer)
84 {
85 _waitForDefaultServer = waitForDefaultServer;
86 }
87
88
89
90 public void setBundleTracker (BundleTracker bundleTracker)
91 {
92 _bundleTracker = bundleTracker;
93 }
94
95
96
97 public void open () throws Exception
98 {
99 if (_waitForDefaultServer && !_defaultServerReady)
100 {
101 String filter = "(&(objectclass=" + BundleProvider.class.getName() + ")"+
102 "("+OSGiServerConstants.MANAGED_JETTY_SERVER_NAME+"="+OSGiServerConstants.MANAGED_JETTY_SERVER_DEFAULT_NAME+"))";
103
104 ServiceTracker defaultServerTracker = new ServiceTracker(_bundle.getBundleContext(),
105 FrameworkUtil.createFilter(filter),null)
106 {
107 public Object addingService(ServiceReference reference)
108 {
109 try
110 {
111 Object object = super.addingService(reference);
112 LOG.debug("Default Jetty Server registered {}", reference);
113 _defaultServerReady = true;
114 openBundleTracker();
115 return object;
116 }
117 catch (Exception e)
118 {
119 throw new IllegalStateException(e);
120 }
121 }
122 };
123 defaultServerTracker.open();
124 }
125 else
126 openBundleTracker();
127 }
128
129
130 public Map<ServiceReference, BundleProvider> getDeployers(String managedServerName)
131 {
132 if (managedServerName == null)
133 managedServerName = OSGiServerConstants.MANAGED_JETTY_SERVER_DEFAULT_NAME;
134
135 Map<ServiceReference, BundleProvider> candidates = new HashMap<ServiceReference, BundleProvider>();
136
137 ServiceReference[] references = _serviceTracker.getServiceReferences();
138 if (references != null)
139 {
140 for (ServiceReference ref:references)
141 {
142 String name = (String)ref.getProperty(OSGiServerConstants.MANAGED_JETTY_SERVER_NAME);
143 if (managedServerName.equalsIgnoreCase(name))
144 {
145 BundleProvider candidate = (BundleProvider)_serviceTracker.getService(ref);
146 if (candidate != null)
147 candidates.put(ref, candidate);
148 }
149 }
150 }
151 return candidates;
152 }
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175 public Object addingBundle(Bundle bundle, BundleEvent event)
176 {
177 if (bundle.getState() == Bundle.ACTIVE)
178 {
179 register(bundle);
180 }
181 else if (bundle.getState() == Bundle.STOPPING)
182 {
183 unregister(bundle);
184 }
185 else
186 {
187
188
189 }
190 return null;
191 }
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208 public void modifiedBundle(Bundle bundle, BundleEvent event, Object object)
209 {
210 if (bundle.getState() == Bundle.STOPPING || bundle.getState() == Bundle.ACTIVE)
211 {
212 unregister(bundle);
213 }
214 if (bundle.getState() == Bundle.ACTIVE)
215 {
216 register(bundle);
217 }
218 }
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235 public void removedBundle(Bundle bundle, BundleEvent event, Object object)
236 {
237 unregister(bundle);
238 }
239
240
241 protected void openBundleTracker()
242 {
243 _bundleTracker.open();
244 }
245
246
247
248
249
250
251 private boolean register(Bundle bundle)
252 {
253 if (bundle == null)
254 return false;
255
256
257
258 boolean deployed = false;
259 String serverName = (String)bundle.getHeaders().get(OSGiServerConstants.MANAGED_JETTY_SERVER_NAME);
260 Map<ServiceReference, BundleProvider> candidates = getDeployers(serverName);
261 if (candidates != null)
262 {
263 Iterator<Entry<ServiceReference, BundleProvider>> itor = candidates.entrySet().iterator();
264 while (!deployed && itor.hasNext())
265 {
266 Entry<ServiceReference, BundleProvider> e = itor.next();
267 try
268 {
269 deployed = e.getValue().bundleAdded(bundle);
270 }
271 catch (Exception x)
272 {
273 LOG.warn("Error deploying bundle for jetty context", x);
274 }
275 }
276 }
277
278 return deployed;
279 }
280
281
282
283
284
285 private void unregister(Bundle bundle)
286 {
287 boolean undeployed = false;
288 String serverName = (String)bundle.getHeaders().get(OSGiServerConstants.MANAGED_JETTY_SERVER_NAME);
289 Map<ServiceReference, BundleProvider> candidates = getDeployers(serverName);
290 if (candidates != null)
291 {
292 Iterator<Entry<ServiceReference, BundleProvider>> itor = candidates.entrySet().iterator();
293 while (!undeployed && itor.hasNext())
294 {
295 Entry<ServiceReference, BundleProvider> e = itor.next();
296 try
297 {
298 undeployed = e.getValue().bundleRemoved(bundle);
299 }
300 catch (Exception x)
301 {
302 LOG.warn("Error undeploying Bundle representing jetty deployable ", x);
303 }
304 }
305 }
306 }
307 }