%line | %branch | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
org.apache.turbine.services.pull.TurbinePullService |
|
|
1 | package org.apache.turbine.services.pull; |
|
2 | ||
3 | /* |
|
4 | * Copyright 2001-2005 The Apache Software Foundation. |
|
5 | * |
|
6 | * Licensed under the Apache License, Version 2.0 (the "License") |
|
7 | * you may not use this file except in compliance with the License. |
|
8 | * You may obtain a copy of the License at |
|
9 | * |
|
10 | * http://www.apache.org/licenses/LICENSE-2.0 |
|
11 | * |
|
12 | * Unless required by applicable law or agreed to in writing, software |
|
13 | * distributed under the License is distributed on an "AS IS" BASIS, |
|
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
15 | * See the License for the specific language governing permissions and |
|
16 | * limitations under the License. |
|
17 | */ |
|
18 | ||
19 | import java.util.ArrayList; |
|
20 | import java.util.Iterator; |
|
21 | import java.util.List; |
|
22 | ||
23 | import org.apache.commons.configuration.Configuration; |
|
24 | ||
25 | import org.apache.commons.logging.Log; |
|
26 | import org.apache.commons.logging.LogFactory; |
|
27 | ||
28 | import org.apache.turbine.Turbine; |
|
29 | import org.apache.turbine.om.security.User; |
|
30 | import org.apache.turbine.services.InitializationException; |
|
31 | import org.apache.turbine.services.TurbineBaseService; |
|
32 | import org.apache.turbine.services.pool.PoolService; |
|
33 | import org.apache.turbine.services.pool.TurbinePool; |
|
34 | import org.apache.turbine.services.security.TurbineSecurity; |
|
35 | import org.apache.turbine.services.velocity.VelocityService; |
|
36 | import org.apache.turbine.services.velocity.TurbineVelocity; |
|
37 | import org.apache.turbine.util.RunData; |
|
38 | ||
39 | import org.apache.velocity.context.Context; |
|
40 | ||
41 | /** |
|
42 | * This is the concrete implementation of the Turbine |
|
43 | * Pull Service. |
|
44 | * <p> |
|
45 | * These are tools that are placed in the context by the service |
|
46 | * These tools will be made available to all your |
|
47 | * templates. You list the tools in the following way: |
|
48 | * <p> |
|
49 | * <pre> |
|
50 | * tool.<scope>.<id> = <classname> |
|
51 | * |
|
52 | * <scope> is the tool scope: global, request, session, |
|
53 | * authorized or persistent (see below for more details) |
|
54 | * <id> is the name of the tool in the context |
|
55 | * |
|
56 | * You can configure the tools in this way: |
|
57 | * tool.<id>.<parameter> = <value> |
|
58 | * |
|
59 | * So if you find "global", "request", "session" or "persistent" as second |
|
60 | * part, it is a configuration to put a tool into the toolbox, else it is a |
|
61 | * tool specific configuration. |
|
62 | * |
|
63 | * For example: |
|
64 | * |
|
65 | * tool.global.ui = org.apache.turbine.util.pull.UIManager |
|
66 | * tool.global.mm = org.apache.turbine.util.pull.MessageManager |
|
67 | * tool.request.link = org.apache.turbine.services.pull.tools.TemplateLink |
|
68 | * tool.request.page = org.apache.turbine.util.template.TemplatePageAttributes |
|
69 | * |
|
70 | * Then: |
|
71 | * |
|
72 | * tool.ui.skin = default |
|
73 | * |
|
74 | * configures the value of "skin" for the "ui" tool. |
|
75 | * |
|
76 | * Tools are accessible in all templates by the <id> given |
|
77 | * to the tool. So for the above listings the UIManager would |
|
78 | * be available as $ui, the MessageManager as $mm, the TemplateLink |
|
79 | * as $link and the TemplatePageAttributes as $page. |
|
80 | * |
|
81 | * You should avoid using tool names called "global", "request", |
|
82 | * "session" or "persistent" because of clashes with the possible Scopes. |
|
83 | * |
|
84 | * Scopes: |
|
85 | * |
|
86 | * global: tool is instantiated once and that instance is available |
|
87 | * to all templates for all requests. Tool must be threadsafe. |
|
88 | * |
|
89 | * request: tool is instantiated once for each request (although the |
|
90 | * PoolService is used to recycle instances). Tool need not |
|
91 | * be threadsafe. |
|
92 | * |
|
93 | * session: tool is instantiated once for each user session, and is |
|
94 | * stored in the session. These tools do not need to be |
|
95 | * threadsafe. |
|
96 | * |
|
97 | * authorized: tool is instantiated once for each user session once the |
|
98 | * user logs in. After this, it is a normal session tool. |
|
99 | * |
|
100 | * persistent: tool is instantitated once for each user session once |
|
101 | * the user logs in and is is stored in the user's permanent |
|
102 | * hashtable. |
|
103 | * This means for a logged in user the tool will be persisted |
|
104 | * in the user's objectdata. Tool should be Serializable. These |
|
105 | * tools do not need to be threadsafe. |
|
106 | * <b>persistent scope tools are deprecated in 2.3</b> |
|
107 | * |
|
108 | * Defaults: none |
|
109 | * </pre> |
|
110 | * |
|
111 | * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a> |
|
112 | * @author <a href="mailto:sean@informage.net">Sean Legassick</a> |
|
113 | * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> |
|
114 | * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a> |
|
115 | * @version $Id: TurbinePullService.java 264148 2005-08-29 14:21:04Z henning $ |
|
116 | */ |
|
117 | 80 | public class TurbinePullService |
118 | extends TurbineBaseService |
|
119 | implements PullService |
|
120 | { |
|
121 | /** Logging */ |
|
122 | 60 | private static Log log = LogFactory.getLog(TurbinePullService.class); |
123 | ||
124 | /** Reference to the pool service */ |
|
125 | 40 | private PoolService pool = null; |
126 | ||
127 | /** Reference to the templating (nee Velocity) service */ |
|
128 | 40 | private VelocityService velocity = null; |
129 | ||
130 | /** |
|
131 | * This is the container for the global web application |
|
132 | * tools that are used in conjunction with the |
|
133 | * Turbine Pull Model. All the global tools will be placed |
|
134 | * in this Context and be made accessible inside |
|
135 | * templates via the tool name specified in the TR.props |
|
136 | * file. |
|
137 | */ |
|
138 | private Context globalContext; |
|
139 | ||
140 | /** |
|
141 | * This inner class is used in the lists below to store the |
|
142 | * tool name and class for each of request, session and persistent |
|
143 | * tools |
|
144 | */ |
|
145 | private static class ToolData |
|
146 | { |
|
147 | String toolName; |
|
148 | String toolClassName; |
|
149 | Class toolClass; |
|
150 | ||
151 | public ToolData(String toolName, String toolClassName, Class toolClass) |
|
152 | { |
|
153 | this.toolName = toolName; |
|
154 | this.toolClassName = toolClassName; |
|
155 | this.toolClass = toolClass; |
|
156 | } |
|
157 | } |
|
158 | ||
159 | /** Internal list of global tools */ |
|
160 | private List globalTools; |
|
161 | ||
162 | /** Internal list of request tools */ |
|
163 | private List requestTools; |
|
164 | ||
165 | /** Internal list of session tools */ |
|
166 | private List sessionTools; |
|
167 | ||
168 | /** Internal list of authorized tools */ |
|
169 | private List authorizedTools; |
|
170 | ||
171 | /** Internal list of persistent tools */ |
|
172 | private List persistentTools; |
|
173 | ||
174 | /** Directory where application tool resources are stored.*/ |
|
175 | private String resourcesDirectory; |
|
176 | ||
177 | /** Should we refresh the application tools on a per request basis? */ |
|
178 | 40 | private boolean refreshToolsPerRequest = false; |
179 | ||
180 | /** |
|
181 | * Called the first time the Service is used. |
|
182 | */ |
|
183 | public void init() |
|
184 | throws InitializationException |
|
185 | { |
|
186 | try |
|
187 | { |
|
188 | 42 | pool = TurbinePool.getService(); |
189 | ||
190 | 42 | if (pool == null) |
191 | { |
|
192 | 0 | throw new InitializationException("Pull Service requires" |
193 | + " configured Pool Service!"); |
|
194 | } |
|
195 | ||
196 | 42 | initPullService(); |
197 | // Make sure to setInit(true) because Tools may |
|
198 | // make calls back to the TurbinePull static methods |
|
199 | // which causes an init loop. |
|
200 | 42 | setInit(true); |
201 | ||
202 | // Do _NOT_ move this before the setInit(true) |
|
203 | 42 | velocity = TurbineVelocity.getService(); |
204 | ||
205 | 42 | if (velocity != null) |
206 | { |
|
207 | 42 | initPullTools(); |
208 | } |
|
209 | else |
|
210 | { |
|
211 | 0 | log.info("Velocity Service not configured, skipping pull tools!"); |
212 | } |
|
213 | 21 | } |
214 | 0 | catch (Exception e) |
215 | { |
|
216 | 0 | throw new InitializationException( |
217 | "TurbinePullService failed to initialize", e); |
|
218 | 21 | } |
219 | 42 | } |
220 | ||
221 | /** |
|
222 | * Initialize the pull service |
|
223 | * |
|
224 | * @exception Exception A problem happened when starting up |
|
225 | */ |
|
226 | private void initPullService() |
|
227 | throws Exception |
|
228 | { |
|
229 | // This is the per-service configuration, prefixed with services.PullService |
|
230 | 42 | Configuration conf = getConfiguration(); |
231 | ||
232 | // Get the resources directory that is specificed |
|
233 | // in the TR.props or default to "resources", relative to the webapp. |
|
234 | 42 | resourcesDirectory = conf.getString( |
235 | TOOL_RESOURCES_DIR_KEY, |
|
236 | TOOL_RESOURCES_DIR_DEFAULT); |
|
237 | ||
238 | // Should we refresh the tool box on a per |
|
239 | // request basis. |
|
240 | 42 | refreshToolsPerRequest = |
241 | conf.getBoolean( |
|
242 | TOOLS_PER_REQUEST_REFRESH_KEY, |
|
243 | TOOLS_PER_REQUEST_REFRESH_DEFAULT); |
|
244 | ||
245 | // Log the fact that the application tool box will |
|
246 | // be refreshed on a per request basis. |
|
247 | 42 | if (refreshToolsPerRequest) |
248 | { |
|
249 | 26 | log.info("Pull Model tools will " |
250 | + "be refreshed on a per request basis."); |
|
251 | } |
|
252 | 42 | } |
253 | ||
254 | /** |
|
255 | * Initialize the pull tools. At this point, the |
|
256 | * service must be marked as initialized, because the |
|
257 | * tools may call the methods of this service via the |
|
258 | * static facade class TurbinePull. |
|
259 | * |
|
260 | * @exception Exception A problem happened when starting up |
|
261 | */ |
|
262 | private void initPullTools() |
|
263 | throws Exception |
|
264 | { |
|
265 | // And for reasons I never really fully understood, |
|
266 | // the tools directive is toplevel without the service |
|
267 | // prefix. This is brain-damaged but for legacy reasons we |
|
268 | // keep this. So this is the global turbine configuration: |
|
269 | 42 | Configuration conf = Turbine.getConfiguration(); |
270 | ||
271 | // Grab each list of tools that are to be used (for global scope, |
|
272 | // request scope, authorized scope, session scope and persistent |
|
273 | // scope tools). They are specified respectively in the TR.props |
|
274 | // like this: |
|
275 | // |
|
276 | // tool.global.ui = org.apache.turbine.util.pull.UIManager |
|
277 | // tool.global.mm = org.apache.turbine.util.pull.MessageManager |
|
278 | // |
|
279 | // tool.request.link = org.apache.turbine.services.pull.tools.TemplateLink |
|
280 | // |
|
281 | // tool.session.basket = org.sample.util.ShoppingBasket; |
|
282 | // |
|
283 | // tool.persistent.ui = org.apache.turbine.services.pull.util.PersistentUIManager |
|
284 | ||
285 | 42 | log.debug("Global Tools:"); |
286 | 42 | globalTools = getTools(conf.subset(GLOBAL_TOOL)); |
287 | 42 | log.debug("Request Tools:"); |
288 | 42 | requestTools = getTools(conf.subset(REQUEST_TOOL)); |
289 | 42 | log.debug("Session Tools:"); |
290 | 42 | sessionTools = getTools(conf.subset(SESSION_TOOL)); |
291 | 42 | log.debug("Authorized Tools:"); |
292 | 42 | authorizedTools = getTools(conf.subset(AUTHORIZED_TOOL)); |
293 | 42 | log.debug("Persistent Tools:"); |
294 | 42 | persistentTools = getTools(conf.subset(PERSISTENT_TOOL)); |
295 | ||
296 | // Create and populate the global context right now |
|
297 | ||
298 | // This is unholy, because it entwines the VelocityService and |
|
299 | // the Pull Service even further. However, there isn't much we can |
|
300 | // do for the 2.3 release. Expect this to go post-2.3 |
|
301 | 42 | globalContext = velocity.getNewContext(); |
302 | ||
303 | 42 | populateWithGlobalTools(globalContext); |
304 | 42 | } |
305 | ||
306 | /** |
|
307 | * Retrieve the tool names and classes for the tools definied |
|
308 | * in the configuration file with the prefix given. |
|
309 | * |
|
310 | * @param toolConfig The part of the configuration describing some tools |
|
311 | */ |
|
312 | private List getTools(Configuration toolConfig) |
|
313 | { |
|
314 | 210 | List tools = new ArrayList(); |
315 | ||
316 | // There might not be any tools for this prefix |
|
317 | // so return an empty list. |
|
318 | 210 | if (toolConfig == null) |
319 | { |
|
320 | 0 | return tools; |
321 | } |
|
322 | ||
323 | 406 | for (Iterator it = toolConfig.getKeys(); it.hasNext();) |
324 | { |
|
325 | 182 | String toolName = (String) it.next(); |
326 | 182 | String toolClassName = toolConfig.getString(toolName); |
327 | ||
328 | try |
|
329 | { |
|
330 | // Create an instance of the tool class. |
|
331 | 182 | Class toolClass = Class.forName(toolClassName); |
332 | ||
333 | // Add the tool to the list being built. |
|
334 | 182 | tools.add(new ToolData(toolName, toolClassName, toolClass)); |
335 | ||
336 | 182 | log.info("Tool " + toolClassName |
337 | + " to add to the context as '$" + toolName + "'"); |
|
338 | 91 | } |
339 | 0 | catch (Exception e) |
340 | { |
|
341 | 0 | log.error("Cannot instantiate tool class " |
342 | + toolClassName + ": ", e); |
|
343 | 182 | } |
344 | } |
|
345 | ||
346 | 210 | return tools; |
347 | } |
|
348 | ||
349 | /** |
|
350 | * Return the Context which contains all global tools that |
|
351 | * are to be used in conjunction with the Turbine |
|
352 | * Pull Model. The tools are refreshed every time the |
|
353 | * global Context is pulled. |
|
354 | */ |
|
355 | public Context getGlobalContext() |
|
356 | { |
|
357 | 8 | if (refreshToolsPerRequest) |
358 | { |
|
359 | 8 | refreshGlobalTools(); |
360 | } |
|
361 | 8 | return globalContext; |
362 | } |
|
363 | ||
364 | /** |
|
365 | * Populate the given context with all request, session, authorized |
|
366 | * and persistent scope tools (it is assumed that the context |
|
367 | * already wraps the global context, and thus already contains |
|
368 | * the global tools). |
|
369 | * |
|
370 | * @param context a Velocity Context to populate |
|
371 | * @param data a RunData object for request specific data |
|
372 | */ |
|
373 | public void populateContext(Context context, RunData data) |
|
374 | { |
|
375 | 0 | populateWithRequestTools(context, data); |
376 | ||
377 | // session tools (whether session-only or persistent are |
|
378 | // very similar, so the same method is used - the |
|
379 | // boolean parameter indicates whether get/setPerm is to be used |
|
380 | // rather than get/setTemp) |
|
381 | ||
382 | // |
|
383 | // Session Tool start right at the session once the user has been set |
|
384 | // while persistent and authorized Tools are started when the user has |
|
385 | // logged in |
|
386 | // |
|
387 | 0 | User user = data.getUser(); |
388 | ||
389 | // Note: Session tools are currently lost after the login action |
|
390 | // because the anonymous user is replaced the the real user object. |
|
391 | // We should either store the session pull tools in the session or |
|
392 | // make Turbine.loginAction() copy the session pull tools into the |
|
393 | // new user object. |
|
394 | 0 | populateWithSessionTools(sessionTools, context, data, user); |
395 | ||
396 | 0 | if (!TurbineSecurity.isAnonymousUser(user)) |
397 | { |
|
398 | 0 | if (user.hasLoggedIn()) |
399 | { |
|
400 | 0 | populateWithSessionTools(authorizedTools, context, data, user); |
401 | 0 | populateWithPermTools(persistentTools, context, data, user); |
402 | } |
|
403 | } |
|
404 | 0 | } |
405 | ||
406 | /** |
|
407 | * Populate the given context with the global tools |
|
408 | * |
|
409 | * @param context a Velocity Context to populate |
|
410 | */ |
|
411 | private void populateWithGlobalTools(Context context) |
|
412 | { |
|
413 | 76 | for (Iterator it = globalTools.iterator(); it.hasNext();) |
414 | { |
|
415 | 26 | ToolData toolData = (ToolData) it.next(); |
416 | try |
|
417 | { |
|
418 | 26 | Object tool = toolData.toolClass.newInstance(); |
419 | ||
420 | // global tools are init'd with a null data parameter |
|
421 | 26 | initTool(tool, null); |
422 | ||
423 | // put the tool in the context |
|
424 | 26 | context.put(toolData.toolName, tool); |
425 | 13 | } |
426 | 0 | catch (Exception e) |
427 | { |
|
428 | 0 | log.error("Could not instantiate global tool " |
429 | + toolData.toolName + " from a " |
|
430 | + toolData.toolClassName + " object", e); |
|
431 | 26 | } |
432 | } |
|
433 | 42 | } |
434 | ||
435 | /** |
|
436 | * Populate the given context with the request-scope tools |
|
437 | * |
|
438 | * @param context a Velocity Context to populate |
|
439 | * @param data a RunData instance |
|
440 | */ |
|
441 | private void populateWithRequestTools(Context context, RunData data) |
|
442 | { |
|
443 | // Iterate the tools |
|
444 | 0 | for (Iterator it = requestTools.iterator(); it.hasNext();) |
445 | { |
|
446 | 0 | ToolData toolData = (ToolData) it.next(); |
447 | try |
|
448 | { |
|
449 | // Fetch Object through the Pool. |
|
450 | 0 | Object tool = pool.getInstance(toolData.toolClass); |
451 | ||
452 | // request tools are init'd with a RunData object |
|
453 | 0 | initTool(tool, data); |
454 | ||
455 | // put the tool in the context |
|
456 | 0 | context.put(toolData.toolName, tool); |
457 | } |
|
458 | 0 | catch (Exception e) |
459 | { |
|
460 | 0 | log.error("Could not instantiate request tool " |
461 | + toolData.toolName + " from a " |
|
462 | + toolData.toolClassName + " object", e); |
|
463 | 0 | } |
464 | } |
|
465 | 0 | } |
466 | ||
467 | /** |
|
468 | * Populate the given context with the session-scoped tools. |
|
469 | * |
|
470 | * @param tools The list of tools with which to populate the |
|
471 | * session. |
|
472 | * @param context The context to populate. |
|
473 | * @param data The current RunData object |
|
474 | * @param user The <code>User</code> object whose storage to |
|
475 | * retrieve the tool from. |
|
476 | */ |
|
477 | private void populateWithSessionTools(List tools, Context context, |
|
478 | RunData data, User user) |
|
479 | { |
|
480 | // Iterate the tools |
|
481 | 0 | for (Iterator it = tools.iterator(); it.hasNext();) |
482 | { |
|
483 | 0 | ToolData toolData = (ToolData) it.next(); |
484 | try |
|
485 | { |
|
486 | // ensure that tool is created only once for a user |
|
487 | // by synchronizing against the user object |
|
488 | 0 | synchronized (data.getSession()) |
489 | { |
|
490 | // first try and fetch the tool from the user's |
|
491 | // hashtable |
|
492 | 0 | Object tool = data.getSession().getAttribute( |
493 | SESSION_TOOLS_ATTRIBUTE_PREFIX |
|
494 | + toolData.toolClassName); |
|
495 | ||
496 | 0 | if (tool == null) |
497 | { |
|
498 | // if not there, an instance must be fetched from |
|
499 | // the pool |
|
500 | 0 | tool = pool.getInstance(toolData.toolClass); |
501 | ||
502 | // session tools are init'd with the User object |
|
503 | 0 | initTool(tool, user); |
504 | ||
505 | // store the newly created tool in the session |
|
506 | 0 | data.getSession().setAttribute( |
507 | SESSION_TOOLS_ATTRIBUTE_PREFIX |
|
508 | + tool.getClass().getName(), tool); |
|
509 | } |
|
510 | ||
511 | // *NOT* else |
|
512 | 0 | if(tool != null) |
513 | { |
|
514 | // This is a semantics change. In the old |
|
515 | // Turbine, Session tools were initialized and |
|
516 | // then refreshed every time they were pulled |
|
517 | // into the context if "refreshToolsPerRequest" |
|
518 | // was wanted. |
|
519 | // |
|
520 | // RunDataApplicationTools now have a parameter |
|
521 | // for refresh. If it is not refreshed immediately |
|
522 | // after init(), the parameter value will be undefined |
|
523 | // until the 2nd run. So we refresh all the session |
|
524 | // tools on every run, even if we just init'ed it. |
|
525 | // |
|
526 | ||
527 | 0 | if (refreshToolsPerRequest) |
528 | { |
|
529 | 0 | refreshTool(tool, data); |
530 | } |
|
531 | ||
532 | // put the tool in the context |
|
533 | 0 | log.debug("Adding " + tool + " to ctx as " |
534 | + toolData.toolName); |
|
535 | 0 | context.put(toolData.toolName, tool); |
536 | } |
|
537 | else |
|
538 | { |
|
539 | 0 | log.info("Tool " + toolData.toolName |
540 | + " was null, skipping it."); |
|
541 | } |
|
542 | 0 | } |
543 | } |
|
544 | 0 | catch (Exception e) |
545 | { |
|
546 | 0 | log.error("Could not instantiate session tool " |
547 | + toolData.toolName + " from a " |
|
548 | + toolData.toolClassName + " object", e); |
|
549 | 0 | } |
550 | } |
|
551 | 0 | } |
552 | ||
553 | /** |
|
554 | * Populate the given context with the perm-scoped tools. |
|
555 | * |
|
556 | * @param tools The list of tools with which to populate the |
|
557 | * session. |
|
558 | * @param context The context to populate. |
|
559 | * @param data The current RunData object |
|
560 | * @param user The <code>User</code> object whose storage to |
|
561 | * retrieve the tool from. |
|
562 | */ |
|
563 | private void populateWithPermTools(List tools, Context context, |
|
564 | RunData data, User user) |
|
565 | { |
|
566 | // Iterate the tools |
|
567 | 0 | for (Iterator it = tools.iterator(); it.hasNext();) |
568 | { |
|
569 | 0 | ToolData toolData = (ToolData) it.next(); |
570 | try |
|
571 | { |
|
572 | // ensure that tool is created only once for a user |
|
573 | // by synchronizing against the user object |
|
574 | 0 | synchronized (user) |
575 | { |
|
576 | // first try and fetch the tool from the user's |
|
577 | // hashtable |
|
578 | 0 | Object tool = user.getPerm(toolData.toolClassName); |
579 | ||
580 | 0 | if (tool == null) |
581 | { |
|
582 | // if not there, an instance must be fetched from |
|
583 | // the pool |
|
584 | 0 | tool = pool.getInstance(toolData.toolClass); |
585 | ||
586 | // session tools are init'd with the User object |
|
587 | 0 | initTool(tool, user); |
588 | ||
589 | // store the newly created tool in the user's hashtable |
|
590 | 0 | user.setPerm(toolData.toolClassName, tool); |
591 | } |
|
592 | ||
593 | // *NOT* else |
|
594 | 0 | if(tool != null) |
595 | { |
|
596 | // This is a semantics change. In the old |
|
597 | // Turbine, Session tools were initialized and |
|
598 | // then refreshed every time they were pulled |
|
599 | // into the context if "refreshToolsPerRequest" |
|
600 | // was wanted. |
|
601 | // |
|
602 | // RunDataApplicationTools now have a parameter |
|
603 | // for refresh. If it is not refreshed immediately |
|
604 | // after init(), the parameter value will be undefined |
|
605 | // until the 2nd run. So we refresh all the session |
|
606 | // tools on every run, even if we just init'ed it. |
|
607 | // |
|
608 | ||
609 | 0 | if (refreshToolsPerRequest) |
610 | { |
|
611 | 0 | refreshTool(tool, data); |
612 | } |
|
613 | ||
614 | // put the tool in the context |
|
615 | 0 | log.debug("Adding " + tool + " to ctx as " |
616 | + toolData.toolName); |
|
617 | 0 | log.warn("Persistent scope tools are deprecated."); |
618 | 0 | context.put(toolData.toolName, tool); |
619 | } |
|
620 | else |
|
621 | { |
|
622 | 0 | log.info("Tool " + toolData.toolName |
623 | + " was null, skipping it."); |
|
624 | } |
|
625 | 0 | } |
626 | } |
|
627 | 0 | catch (Exception e) |
628 | { |
|
629 | 0 | log.error("Could not instantiate perm tool " |
630 | + toolData.toolName + " from a " |
|
631 | + toolData.toolClassName + " object", e); |
|
632 | 0 | } |
633 | } |
|
634 | 0 | } |
635 | ||
636 | /** |
|
637 | * Return the absolute path to the resources directory |
|
638 | * used by the application tools. |
|
639 | * |
|
640 | * @return the absolute path of the resources directory |
|
641 | */ |
|
642 | public String getAbsolutePathToResourcesDirectory() |
|
643 | { |
|
644 | 0 | return Turbine.getRealPath(resourcesDirectory); |
645 | } |
|
646 | ||
647 | /** |
|
648 | * Return the resources directory. This is |
|
649 | * relative to the web context. |
|
650 | * |
|
651 | * @return the relative path of the resources directory |
|
652 | */ |
|
653 | public String getResourcesDirectory() |
|
654 | { |
|
655 | 26 | return resourcesDirectory; |
656 | } |
|
657 | ||
658 | /** |
|
659 | * Refresh the global tools. We can |
|
660 | * only refresh those tools that adhere to |
|
661 | * ApplicationTool interface because we |
|
662 | * know those types of tools have a refresh |
|
663 | * method. |
|
664 | * @deprecated Will be made private after 2.3 |
|
665 | */ |
|
666 | public void refreshGlobalTools() |
|
667 | { |
|
668 | 16 | for (Iterator it = globalTools.iterator(); it.hasNext();) |
669 | { |
|
670 | 8 | ToolData toolData = (ToolData) it.next(); |
671 | 8 | Object tool = globalContext.get(toolData.toolName); |
672 | 8 | refreshTool(tool, null); |
673 | } |
|
674 | 8 | } |
675 | ||
676 | /** |
|
677 | * Should we refresh the ToolBox on |
|
678 | * a per request basis. |
|
679 | * @deprecated No longer needed as Pull and Velocity Service are now more separate. |
|
680 | */ |
|
681 | public boolean refreshToolsPerRequest() |
|
682 | { |
|
683 | 0 | return refreshToolsPerRequest; |
684 | } |
|
685 | ||
686 | /** |
|
687 | * Release the request-scope tool instances in the |
|
688 | * given Context back to the pool |
|
689 | * |
|
690 | * @param context the Velocity Context to release tools from |
|
691 | */ |
|
692 | public void releaseTools(Context context) |
|
693 | { |
|
694 | // only the request tools can be released - other scoped |
|
695 | // tools will have continuing references to them |
|
696 | 0 | releaseTools(context, requestTools); |
697 | 0 | } |
698 | ||
699 | /** |
|
700 | * Release the given list of tools from the context back |
|
701 | * to the pool |
|
702 | * |
|
703 | * @param context the Context containing the tools |
|
704 | * @param tools a List of ToolData objects |
|
705 | */ |
|
706 | private void releaseTools(Context context, List tools) |
|
707 | { |
|
708 | 0 | for (Iterator it = tools.iterator(); it.hasNext();) |
709 | { |
|
710 | 0 | ToolData toolData = (ToolData) it.next(); |
711 | 0 | Object tool = context.remove(toolData.toolName); |
712 | ||
713 | 0 | if (tool != null) |
714 | { |
|
715 | 0 | pool.putInstance(tool); |
716 | } |
|
717 | } |
|
718 | 0 | } |
719 | ||
720 | /** |
|
721 | * Initialized a given Tool with the passed init Object |
|
722 | * |
|
723 | * @param tool A Tool Object |
|
724 | * @param param The Init Parameter |
|
725 | * |
|
726 | * @throws Exception If anything went wrong. |
|
727 | */ |
|
728 | private void initTool(Object tool, Object param) |
|
729 | throws Exception |
|
730 | { |
|
731 | 26 | if (tool instanceof ApplicationTool) |
732 | { |
|
733 | 26 | ((ApplicationTool) tool).init(param); |
734 | } |
|
735 | 0 | else if (tool instanceof RunDataApplicationTool) |
736 | { |
|
737 | 0 | ((RunDataApplicationTool) tool).init(param); |
738 | } |
|
739 | 26 | } |
740 | ||
741 | /** |
|
742 | * Refresh a given Tool. |
|
743 | * |
|
744 | * @param tool A Tool Object |
|
745 | * @param data The current RunData Object |
|
746 | */ |
|
747 | private void refreshTool(Object tool, RunData data) |
|
748 | { |
|
749 | 8 | if (tool instanceof ApplicationTool) |
750 | { |
|
751 | 8 | ((ApplicationTool) tool).refresh(); |
752 | } |
|
753 | 0 | else if (tool instanceof RunDataApplicationTool) |
754 | { |
|
755 | 0 | ((RunDataApplicationTool) tool).refresh(data); |
756 | } |
|
757 | 8 | } |
758 | } |
This report is generated by jcoverage, Maven and Maven JCoverage Plugin. |