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