Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
TurbinePullService |
|
| 3.5652173913043477;3,565 | ||||
TurbinePullService$ToolData |
|
| 3.5652173913043477;3,565 |
1 | package org.apache.turbine.services.pull; | |
2 | ||
3 | ||
4 | /* | |
5 | * Licensed to the Apache Software Foundation (ASF) under one | |
6 | * or more contributor license agreements. See the NOTICE file | |
7 | * distributed with this work for additional information | |
8 | * regarding copyright ownership. The ASF licenses this file | |
9 | * to you under the Apache License, Version 2.0 (the | |
10 | * "License"); you may not use this file except in compliance | |
11 | * with the License. You may obtain a copy of the License at | |
12 | * | |
13 | * http://www.apache.org/licenses/LICENSE-2.0 | |
14 | * | |
15 | * Unless required by applicable law or agreed to in writing, | |
16 | * software distributed under the License is distributed on an | |
17 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
18 | * KIND, either express or implied. See the License for the | |
19 | * specific language governing permissions and limitations | |
20 | * under the License. | |
21 | */ | |
22 | ||
23 | ||
24 | import java.util.ArrayList; | |
25 | import java.util.Iterator; | |
26 | import java.util.List; | |
27 | ||
28 | import org.apache.commons.configuration.Configuration; | |
29 | import org.apache.commons.logging.Log; | |
30 | import org.apache.commons.logging.LogFactory; | |
31 | import org.apache.fulcrum.pool.PoolService; | |
32 | import org.apache.fulcrum.security.model.turbine.TurbineUserManager; | |
33 | import org.apache.turbine.Turbine; | |
34 | import org.apache.turbine.annotation.AnnotationProcessor; | |
35 | import org.apache.turbine.om.security.User; | |
36 | import org.apache.turbine.pipeline.PipelineData; | |
37 | import org.apache.turbine.services.InitializationException; | |
38 | import org.apache.turbine.services.TurbineBaseService; | |
39 | import org.apache.turbine.services.TurbineServices; | |
40 | import org.apache.turbine.services.velocity.VelocityService; | |
41 | import org.apache.turbine.util.RunData; | |
42 | import org.apache.velocity.context.Context; | |
43 | ||
44 | /** | |
45 | * This is the concrete implementation of the Turbine | |
46 | * Pull Service. | |
47 | * <p> | |
48 | * These are tools that are placed in the context by the service | |
49 | * These tools will be made available to all your | |
50 | * templates. You list the tools in the following way: | |
51 | * </p> | |
52 | * <pre> | |
53 | * tool.<scope>.<id> = <classname> | |
54 | * | |
55 | * <scope> is the tool scope: global, request, session, | |
56 | * authorized or persistent (see below for more details) | |
57 | * <id> is the name of the tool in the context | |
58 | * | |
59 | * You can configure the tools in this way: | |
60 | * tool.<id>.<parameter> = <value> | |
61 | * | |
62 | * So if you find "global", "request", "session" or "persistent" as second | |
63 | * part, it is a configuration to put a tool into the toolbox, else it is a | |
64 | * tool specific configuration. | |
65 | * | |
66 | * For example: | |
67 | * | |
68 | * tool.global.ui = org.apache.turbine.util.pull.UIManager | |
69 | * tool.global.mm = org.apache.turbine.util.pull.MessageManager | |
70 | * tool.request.link = org.apache.turbine.services.pull.tools.TemplateLink | |
71 | * tool.request.page = org.apache.turbine.util.template.TemplatePageAttributes | |
72 | * | |
73 | * Then: | |
74 | * | |
75 | * tool.ui.skin = default | |
76 | * | |
77 | * configures the value of "skin" for the "ui" tool. | |
78 | * | |
79 | * Tools are accessible in all templates by the <id> given | |
80 | * to the tool. So for the above listings the UIManager would | |
81 | * be available as $ui, the MessageManager as $mm, the TemplateLink | |
82 | * as $link and the TemplatePageAttributes as $page. | |
83 | * | |
84 | * You should avoid using tool names called "global", "request", | |
85 | * "session" or "persistent" because of clashes with the possible Scopes. | |
86 | * | |
87 | * Scopes: | |
88 | * | |
89 | * global: tool is instantiated once and that instance is available | |
90 | * to all templates for all requests. Tool must be threadsafe. | |
91 | * | |
92 | * request: tool is instantiated once for each request (although the | |
93 | * PoolService is used to recycle instances). Tool need not | |
94 | * be threadsafe. | |
95 | * | |
96 | * session: tool is instantiated once for each user session, and is | |
97 | * stored in the session. These tools do not need to be | |
98 | * threadsafe. | |
99 | * | |
100 | * authorized: tool is instantiated once for each user session once the | |
101 | * user logs in. After this, it is a normal session tool. | |
102 | * | |
103 | * persistent: tool is instantitated once for each user session once | |
104 | * the user logs in and is is stored in the user's permanent | |
105 | * hashtable. | |
106 | * This means for a logged in user the tool will be persisted | |
107 | * in the user's objectdata. Tool should be Serializable. These | |
108 | * tools do not need to be threadsafe. | |
109 | * <b>persistent scope tools are deprecated in 2.3</b> | |
110 | * | |
111 | * Defaults: none | |
112 | * </pre> | |
113 | * | |
114 | * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a> | |
115 | * @author <a href="mailto:sean@informage.net">Sean Legassick</a> | |
116 | * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> | |
117 | * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a> | |
118 | * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a> | |
119 | * @version $Id: TurbinePullService.java 1773378 2016-12-09 13:19:59Z tv $ | |
120 | */ | |
121 | 32 | public class TurbinePullService |
122 | extends TurbineBaseService | |
123 | implements PullService | |
124 | { | |
125 | /** Logging */ | |
126 | 32 | private static Log log = LogFactory.getLog(TurbinePullService.class); |
127 | ||
128 | /** Reference to the pool service */ | |
129 | 32 | private PoolService pool = null; |
130 | ||
131 | /** Reference to the templating (nee Velocity) service */ | |
132 | 32 | private VelocityService velocity = null; |
133 | ||
134 | /** | |
135 | * This is the container for the global web application | |
136 | * tools that are used in conjunction with the | |
137 | * Turbine Pull Model. All the global tools will be placed | |
138 | * in this Context and be made accessible inside | |
139 | * templates via the tool name specified in the TR.props | |
140 | * file. | |
141 | */ | |
142 | private Context globalContext; | |
143 | ||
144 | /** | |
145 | * This inner class is used in the lists below to store the | |
146 | * tool name and class for each of request, session and persistent | |
147 | * tools | |
148 | */ | |
149 | private static class ToolData | |
150 | { | |
151 | String toolName; | |
152 | String toolClassName; | |
153 | Class<ApplicationTool> toolClass; | |
154 | ||
155 | public ToolData(String toolName, String toolClassName, Class<ApplicationTool> toolClass) | |
156 | 133 | { |
157 | 133 | this.toolName = toolName; |
158 | 133 | this.toolClassName = toolClassName; |
159 | 133 | this.toolClass = toolClass; |
160 | 133 | } |
161 | } | |
162 | ||
163 | /** Internal list of global tools */ | |
164 | private List<ToolData> globalTools; | |
165 | ||
166 | /** Internal list of request tools */ | |
167 | private List<ToolData> requestTools; | |
168 | ||
169 | /** Internal list of session tools */ | |
170 | private List<ToolData> sessionTools; | |
171 | ||
172 | /** Internal list of authorized tools */ | |
173 | private List<ToolData> authorizedTools; | |
174 | ||
175 | /** Internal list of persistent tools */ | |
176 | private List<ToolData> persistentTools; | |
177 | ||
178 | /** Directory where application tool resources are stored.*/ | |
179 | private String resourcesDirectory; | |
180 | ||
181 | /** Should we refresh the application tools on a per request basis? */ | |
182 | 32 | private boolean refreshToolsPerRequest = false; |
183 | ||
184 | /** | |
185 | * Called the first time the Service is used. | |
186 | */ | |
187 | @Override | |
188 | public void init() | |
189 | throws InitializationException | |
190 | { | |
191 | try | |
192 | { | |
193 | 39 | pool = (PoolService)TurbineServices.getInstance().getService(PoolService.ROLE); |
194 | ||
195 | 39 | if (pool == null) |
196 | { | |
197 | 0 | throw new InitializationException("Pull Service requires" |
198 | + " configured Pool Service!"); | |
199 | } | |
200 | ||
201 | 39 | initPullService(); |
202 | // Make sure to setInit(true) because Tools may | |
203 | // make calls back to the TurbinePull static methods | |
204 | // which causes an init loop. | |
205 | 39 | setInit(true); |
206 | ||
207 | // Do _NOT_ move this before the setInit(true) | |
208 | 39 | velocity = (VelocityService)TurbineServices.getInstance().getService(VelocityService.SERVICE_NAME); |
209 | ||
210 | 28 | if (velocity != null) |
211 | { | |
212 | 28 | initPullTools(); |
213 | } | |
214 | else | |
215 | { | |
216 | 0 | log.info("Velocity Service not configured, skipping pull tools!"); |
217 | } | |
218 | } | |
219 | 11 | catch (Exception e) |
220 | { | |
221 | 11 | throw new InitializationException("TurbinePullService failed to initialize", e); |
222 | 28 | } |
223 | 28 | } |
224 | ||
225 | /** | |
226 | * Initialize the pull service | |
227 | * | |
228 | * @throws Exception A problem happened when starting up | |
229 | */ | |
230 | private void initPullService() | |
231 | throws Exception | |
232 | { | |
233 | // This is the per-service configuration, prefixed with services.PullService | |
234 | 39 | Configuration conf = getConfiguration(); |
235 | ||
236 | // Get the resources directory that is specificed | |
237 | // in the TR.props or default to "resources", relative to the webapp. | |
238 | 39 | resourcesDirectory = conf.getString( |
239 | TOOL_RESOURCES_DIR_KEY, | |
240 | TOOL_RESOURCES_DIR_DEFAULT); | |
241 | ||
242 | // Should we refresh the tool box on a per | |
243 | // request basis. | |
244 | 39 | refreshToolsPerRequest = |
245 | conf.getBoolean( | |
246 | TOOLS_PER_REQUEST_REFRESH_KEY, | |
247 | TOOLS_PER_REQUEST_REFRESH_DEFAULT); | |
248 | ||
249 | // Log the fact that the application tool box will | |
250 | // be refreshed on a per request basis. | |
251 | 39 | if (refreshToolsPerRequest) |
252 | { | |
253 | 30 | log.info("Pull Model tools will " |
254 | + "be refreshed on a per request basis."); | |
255 | } | |
256 | 39 | } |
257 | ||
258 | /** | |
259 | * Initialize the pull tools. At this point, the | |
260 | * service must be marked as initialized, because the | |
261 | * tools may call the methods of this service via the | |
262 | * static facade class TurbinePull. | |
263 | * | |
264 | * @throws Exception A problem happened when starting up | |
265 | */ | |
266 | private void initPullTools() | |
267 | throws Exception | |
268 | { | |
269 | // And for reasons I never really fully understood, | |
270 | // the tools directive is toplevel without the service | |
271 | // prefix. This is brain-damaged but for legacy reasons we | |
272 | // keep this. So this is the global turbine configuration: | |
273 | 28 | Configuration conf = Turbine.getConfiguration(); |
274 | ||
275 | // Grab each list of tools that are to be used (for global scope, | |
276 | // request scope, authorized scope, session scope and persistent | |
277 | // scope tools). They are specified respectively in the TR.props | |
278 | // like this: | |
279 | // | |
280 | // tool.global.ui = org.apache.turbine.util.pull.UIManager | |
281 | // tool.global.mm = org.apache.turbine.util.pull.MessageManager | |
282 | // | |
283 | // tool.request.link = org.apache.turbine.services.pull.tools.TemplateLink | |
284 | // | |
285 | // tool.session.basket = org.sample.util.ShoppingBasket; | |
286 | // | |
287 | // tool.persistent.ui = org.apache.turbine.services.pull.util.PersistentUIManager | |
288 | ||
289 | 28 | log.debug("Global Tools:"); |
290 | 28 | globalTools = getTools(conf.subset(GLOBAL_TOOL)); |
291 | 28 | log.debug("Request Tools:"); |
292 | 28 | requestTools = getTools(conf.subset(REQUEST_TOOL)); |
293 | 28 | log.debug("Session Tools:"); |
294 | 28 | sessionTools = getTools(conf.subset(SESSION_TOOL)); |
295 | 28 | log.debug("Authorized Tools:"); |
296 | 28 | authorizedTools = getTools(conf.subset(AUTHORIZED_TOOL)); |
297 | 28 | log.debug("Persistent Tools:"); |
298 | 28 | persistentTools = getTools(conf.subset(PERSISTENT_TOOL)); |
299 | ||
300 | // Create and populate the global context right now | |
301 | ||
302 | // This is unholy, because it entwines the VelocityService and | |
303 | // the Pull Service even further. However, there isn't much we can | |
304 | // do for the 2.3 release. Expect this to go post-2.3 | |
305 | 28 | globalContext = velocity.getNewContext(); |
306 | ||
307 | 28 | populateWithGlobalTools(globalContext); |
308 | 28 | } |
309 | ||
310 | /** | |
311 | * Retrieve the tool names and classes for the tools defined | |
312 | * in the configuration file with the prefix given. | |
313 | * | |
314 | * @param toolConfig The part of the configuration describing some tools | |
315 | */ | |
316 | @SuppressWarnings("unchecked") | |
317 | private List<ToolData> getTools(Configuration toolConfig) | |
318 | { | |
319 | 140 | List<ToolData> tools = new ArrayList<ToolData>(); |
320 | ||
321 | // There might not be any tools for this prefix | |
322 | // so return an empty list. | |
323 | 140 | if (toolConfig == null) |
324 | { | |
325 | 0 | return tools; |
326 | } | |
327 | ||
328 | 140 | for (Iterator<String> it = toolConfig.getKeys(); it.hasNext();) |
329 | { | |
330 | 133 | String toolName = it.next(); |
331 | 133 | String toolClassName = toolConfig.getString(toolName); |
332 | ||
333 | try | |
334 | { | |
335 | // Create an instance of the tool class. | |
336 | 133 | Class<ApplicationTool> toolClass = (Class<ApplicationTool>) Class.forName(toolClassName); |
337 | ||
338 | // Add the tool to the list being built. | |
339 | 133 | tools.add(new ToolData(toolName, toolClassName, toolClass)); |
340 | ||
341 | 133 | log.info("Tool " + toolClassName |
342 | + " to add to the context as '$" + toolName + "'"); | |
343 | } | |
344 | // NoClassDefFoundError + ClassNotFoundException | |
345 | 0 | catch (Throwable e) |
346 | { | |
347 | 0 | log.error("Cannot instantiate tool class " |
348 | + toolClassName + ": ", e); | |
349 | 133 | } |
350 | 133 | } |
351 | ||
352 | 140 | return tools; |
353 | } | |
354 | ||
355 | /** | |
356 | * Return the Context which contains all global tools that | |
357 | * are to be used in conjunction with the Turbine | |
358 | * Pull Model. The tools are refreshed every time the | |
359 | * global Context is pulled. | |
360 | */ | |
361 | @Override | |
362 | public Context getGlobalContext() | |
363 | { | |
364 | 10 | if (refreshToolsPerRequest) |
365 | { | |
366 | 10 | refreshGlobalTools(); |
367 | } | |
368 | 10 | return globalContext; |
369 | } | |
370 | ||
371 | /** | |
372 | * Populate the given context with all request, session, authorized | |
373 | * and persistent scope tools (it is assumed that the context | |
374 | * already wraps the global context, and thus already contains | |
375 | * the global tools). | |
376 | * | |
377 | * @param context a Velocity Context to populate | |
378 | * @param data a RunData object for request specific data | |
379 | */ | |
380 | @Override | |
381 | public void populateContext(Context context, RunData data) | |
382 | { | |
383 | 0 | populateWithRequestTools(context, data); |
384 | ||
385 | // session tools (whether session-only or persistent are | |
386 | // very similar, so the same method is used - the | |
387 | // boolean parameter indicates whether get/setPerm is to be used | |
388 | // rather than get/setTemp) | |
389 | ||
390 | // | |
391 | // Session Tool start right at the session once the user has been set | |
392 | // while persistent and authorized Tools are started when the user has | |
393 | // logged in | |
394 | // | |
395 | 0 | User user = data.getUser(); |
396 | ||
397 | // Note: Session tools are currently lost after the login action | |
398 | // because the anonymous user is replaced the the real user object. | |
399 | // We should either store the session pull tools in the session or | |
400 | // make Turbine.loginAction() copy the session pull tools into the | |
401 | // new user object. | |
402 | 0 | populateWithSessionTools(sessionTools, context, data, user); |
403 | ||
404 | 0 | TurbineUserManager userManager = |
405 | (TurbineUserManager)TurbineServices | |
406 | .getInstance() | |
407 | .getService(TurbineUserManager.ROLE); | |
408 | ||
409 | 0 | if (!userManager.isAnonymousUser(user)) |
410 | { | |
411 | 0 | if (user.hasLoggedIn()) |
412 | { | |
413 | 0 | populateWithSessionTools(authorizedTools, context, data, user); |
414 | 0 | populateWithPermTools(persistentTools, context, data, user); |
415 | } | |
416 | } | |
417 | 0 | } |
418 | ||
419 | /** | |
420 | * Populate the given context with all request, session, authorized | |
421 | * and persistent scope tools (it is assumed that the context | |
422 | * already wraps the global context, and thus already contains | |
423 | * the global tools). | |
424 | * | |
425 | * @param context a Velocity Context to populate | |
426 | * @param pipelineData a PipelineData object for request specific data | |
427 | */ | |
428 | @Override | |
429 | public void populateContext(Context context, PipelineData pipelineData) | |
430 | { | |
431 | // Map runDataMap = (Map) pipelineData.get(RunData.class); | |
432 | // RunData data = (RunData)runDataMap.get(RunData.class); | |
433 | 9 | RunData data = (RunData)pipelineData; |
434 | ||
435 | 9 | populateWithRequestTools(context, pipelineData); |
436 | // session tools (whether session-only or persistent are | |
437 | // very similar, so the same method is used - the | |
438 | // boolean parameter indicates whether get/setPerm is to be used | |
439 | // rather than get/setTemp) | |
440 | ||
441 | // | |
442 | // Session Tool start right at the session once the user has been set | |
443 | // while persistent and authorized Tools are started when the user has | |
444 | // logged in | |
445 | // | |
446 | 9 | User user = data.getUser(); |
447 | ||
448 | // Note: Session tools are currently lost after the login action | |
449 | // because the anonymous user is replaced the the real user object. | |
450 | // We should either store the session pull tools in the session or | |
451 | // make Turbine.loginAction() copy the session pull tools into the | |
452 | // new user object. | |
453 | 9 | populateWithSessionTools(sessionTools, context, pipelineData, user); |
454 | ||
455 | 9 | TurbineUserManager userManager = |
456 | (TurbineUserManager)TurbineServices | |
457 | .getInstance() | |
458 | .getService(TurbineUserManager.ROLE); | |
459 | ||
460 | 9 | if (!userManager.isAnonymousUser(user)) |
461 | { | |
462 | 2 | if (user.hasLoggedIn()) |
463 | { | |
464 | 2 | populateWithSessionTools(authorizedTools, context, pipelineData, user); |
465 | 2 | populateWithPermTools(persistentTools, context, pipelineData, user); |
466 | } | |
467 | } | |
468 | 9 | } |
469 | ||
470 | /** | |
471 | * Populate the given context with the global tools | |
472 | * | |
473 | * @param context a Velocity Context to populate | |
474 | */ | |
475 | private void populateWithGlobalTools(Context context) | |
476 | { | |
477 | 28 | for (Iterator<ToolData> it = globalTools.iterator(); it.hasNext();) |
478 | { | |
479 | 19 | ToolData toolData = it.next(); |
480 | try | |
481 | { | |
482 | 19 | Object tool = toolData.toolClass.newInstance(); |
483 | ||
484 | // global tools are init'd with a null data parameter | |
485 | 19 | initTool(tool, null); |
486 | ||
487 | // put the tool in the context | |
488 | 19 | context.put(toolData.toolName, tool); |
489 | } | |
490 | 0 | catch (Exception e) |
491 | { | |
492 | 0 | log.error("Could not instantiate global tool " |
493 | + toolData.toolName + " from a " | |
494 | + toolData.toolClassName + " object", e); | |
495 | 19 | } |
496 | 19 | } |
497 | 28 | } |
498 | ||
499 | /** | |
500 | * Populate the given context with the request-scope tools | |
501 | * | |
502 | * @param context a Velocity Context to populate | |
503 | * @param pipelineData a RunData instance | |
504 | */ | |
505 | private void populateWithRequestTools(Context context, RunData data) | |
506 | { | |
507 | // Iterate the tools | |
508 | 0 | for (Iterator<ToolData> it = requestTools.iterator(); it.hasNext();) |
509 | { | |
510 | 0 | ToolData toolData = it.next(); |
511 | try | |
512 | { | |
513 | // Fetch Object through the Pool. | |
514 | 0 | Object tool = pool.getInstance(toolData.toolClass); |
515 | ||
516 | // request tools are init'd with a RunData object | |
517 | 0 | initTool(tool, data); |
518 | ||
519 | // put the tool in the context | |
520 | 0 | context.put(toolData.toolName, tool); |
521 | } | |
522 | 0 | catch (Exception e) |
523 | { | |
524 | 0 | log.error("Could not instantiate request tool " |
525 | + toolData.toolName + " from a " | |
526 | + toolData.toolClassName + " object", e); | |
527 | 0 | } |
528 | 0 | } |
529 | 0 | } |
530 | ||
531 | ||
532 | /** | |
533 | * Populate the given context with the request-scope tools | |
534 | * | |
535 | * @param context a Velocity Context to populate | |
536 | * @param pipelineData a RunData instance | |
537 | */ | |
538 | private void populateWithRequestTools(Context context, PipelineData pipelineData) | |
539 | { | |
540 | // Iterate the tools | |
541 | 9 | for (Iterator<ToolData> it = requestTools.iterator(); it.hasNext();) |
542 | { | |
543 | 45 | ToolData toolData = it.next(); |
544 | try | |
545 | { | |
546 | // Fetch Object through the Pool. | |
547 | 45 | Object tool = pool.getInstance(toolData.toolClass); |
548 | ||
549 | 45 | initTool(tool, pipelineData); |
550 | ||
551 | // put the tool in the context | |
552 | 45 | context.put(toolData.toolName, tool); |
553 | } | |
554 | 0 | catch (Exception e) |
555 | { | |
556 | 0 | log.error("Could not instantiate request tool " |
557 | + toolData.toolName + " from a " | |
558 | + toolData.toolClassName + " object", e); | |
559 | 45 | } |
560 | 45 | } |
561 | 9 | } |
562 | ||
563 | /** | |
564 | * Populate the given context with the session-scoped tools. | |
565 | * | |
566 | * @param tools The list of tools with which to populate the | |
567 | * session. | |
568 | * @param context The context to populate. | |
569 | * @param pipelineData The current RunData object | |
570 | * @param user The <code>User</code> object whose storage to | |
571 | * retrieve the tool from. | |
572 | */ | |
573 | private void populateWithSessionTools(List<ToolData> tools, Context context, | |
574 | PipelineData pipelineData, User user) | |
575 | { | |
576 | //Map runDataMap = (Map)pipelineData.get(RunData.class); | |
577 | //RunData data = (RunData) runDataMap.get(RunData.class); | |
578 | 11 | RunData runData = (RunData)pipelineData; |
579 | // Iterate the tools | |
580 | 11 | for (Iterator<ToolData> it = tools.iterator(); it.hasNext();) |
581 | { | |
582 | 9 | ToolData toolData = it.next(); |
583 | try | |
584 | { | |
585 | // ensure that tool is created only once for a user | |
586 | // by synchronizing against the user object | |
587 | 9 | synchronized (runData.getSession()) |
588 | { | |
589 | // first try and fetch the tool from the user's | |
590 | // hashtable | |
591 | 9 | Object tool = runData.getSession().getAttribute( |
592 | SESSION_TOOLS_ATTRIBUTE_PREFIX | |
593 | + toolData.toolClassName); | |
594 | ||
595 | 9 | if (tool == null) |
596 | { | |
597 | // if not there, an instance must be fetched from | |
598 | // the pool | |
599 | 9 | tool = pool.getInstance(toolData.toolClass); |
600 | ||
601 | // session tools are init'd with the User object | |
602 | 9 | initTool(tool, user); |
603 | } | |
604 | ||
605 | // *NOT* else | |
606 | 9 | if(tool != null) |
607 | { | |
608 | // store the newly created tool in the session | |
609 | 9 | runData.getSession().setAttribute( |
610 | SESSION_TOOLS_ATTRIBUTE_PREFIX | |
611 | + tool.getClass().getName(), tool); | |
612 | ||
613 | // This is a semantics change. In the old | |
614 | // Turbine, Session tools were initialized and | |
615 | // then refreshed every time they were pulled | |
616 | // into the context if "refreshToolsPerRequest" | |
617 | // was wanted. | |
618 | // | |
619 | // RunDataApplicationTools now have a parameter | |
620 | // for refresh. If it is not refreshed immediately | |
621 | // after init(), the parameter value will be undefined | |
622 | // until the 2nd run. So we refresh all the session | |
623 | // tools on every run, even if we just init'ed it. | |
624 | // | |
625 | ||
626 | 9 | if (refreshToolsPerRequest) |
627 | { | |
628 | 9 | refreshTool(tool, pipelineData); |
629 | } | |
630 | ||
631 | // put the tool in the context | |
632 | 9 | log.debug("Adding " + tool + " to ctx as " |
633 | + toolData.toolName); | |
634 | 9 | context.put(toolData.toolName, tool); |
635 | } | |
636 | else | |
637 | { | |
638 | 0 | log.info("Tool " + toolData.toolName |
639 | + " was null, skipping it."); | |
640 | } | |
641 | 9 | } |
642 | } | |
643 | 0 | catch (Exception e) |
644 | { | |
645 | 0 | log.error("Could not instantiate session tool " |
646 | + toolData.toolName + " from a " | |
647 | + toolData.toolClassName + " object", e); | |
648 | 9 | } |
649 | 9 | } |
650 | 11 | } |
651 | ||
652 | /** | |
653 | * Populate the given context with the session-scoped tools. | |
654 | * | |
655 | * @param tools The list of tools with which to populate the | |
656 | * session. | |
657 | * @param context The context to populate. | |
658 | * @param pipelineData The current RunData object | |
659 | * @param user The <code>User</code> object whose storage to | |
660 | * retrieve the tool from. | |
661 | */ | |
662 | private void populateWithSessionTools(List<ToolData> tools, Context context, | |
663 | RunData data, User user) | |
664 | { | |
665 | // Iterate the tools | |
666 | 0 | for (Iterator<ToolData> it = tools.iterator(); it.hasNext();) |
667 | { | |
668 | 0 | ToolData toolData = it.next(); |
669 | try | |
670 | { | |
671 | // ensure that tool is created only once for a user | |
672 | // by synchronizing against the user object | |
673 | 0 | synchronized (data.getSession()) |
674 | { | |
675 | // first try and fetch the tool from the user's | |
676 | // hashmap | |
677 | 0 | Object tool = data.getSession().getAttribute( |
678 | SESSION_TOOLS_ATTRIBUTE_PREFIX | |
679 | + toolData.toolClassName); | |
680 | ||
681 | 0 | if (tool == null) |
682 | { | |
683 | // if not there, an instance must be fetched from | |
684 | // the pool | |
685 | 0 | tool = pool.getInstance(toolData.toolClass); |
686 | ||
687 | // session tools are init'd with the User object | |
688 | 0 | initTool(tool, user); |
689 | } | |
690 | ||
691 | // *NOT* else | |
692 | 0 | if(tool != null) |
693 | { | |
694 | // store the newly created tool in the session | |
695 | 0 | data.getSession().setAttribute( |
696 | SESSION_TOOLS_ATTRIBUTE_PREFIX | |
697 | + tool.getClass().getName(), tool); | |
698 | ||
699 | // This is a semantics change. In the old | |
700 | // Turbine, Session tools were initialized and | |
701 | // then refreshed every time they were pulled | |
702 | // into the context if "refreshToolsPerRequest" | |
703 | // was wanted. | |
704 | // | |
705 | // RunDataApplicationTools now have a parameter | |
706 | // for refresh. If it is not refreshed immediately | |
707 | // after init(), the parameter value will be undefined | |
708 | // until the 2nd run. So we refresh all the session | |
709 | // tools on every run, even if we just init'ed it. | |
710 | // | |
711 | ||
712 | 0 | if (refreshToolsPerRequest) |
713 | { | |
714 | 0 | refreshTool(tool, data); |
715 | } | |
716 | ||
717 | // put the tool in the context | |
718 | 0 | log.debug("Adding " + tool + " to ctx as " |
719 | + toolData.toolName); | |
720 | 0 | context.put(toolData.toolName, tool); |
721 | } | |
722 | else | |
723 | { | |
724 | 0 | log.info("Tool " + toolData.toolName |
725 | + " was null, skipping it."); | |
726 | } | |
727 | 0 | } |
728 | } | |
729 | 0 | catch (Exception e) |
730 | { | |
731 | 0 | log.error("Could not instantiate session tool " |
732 | + toolData.toolName + " from a " | |
733 | + toolData.toolClassName + " object", e); | |
734 | 0 | } |
735 | 0 | } |
736 | 0 | } |
737 | ||
738 | ||
739 | ||
740 | /** | |
741 | * Populate the given context with the perm-scoped tools. | |
742 | * | |
743 | * @param tools The list of tools with which to populate the | |
744 | * session. | |
745 | * @param context The context to populate. | |
746 | * @param pipelineData The current RunData object | |
747 | * @param user The <code>User</code> object whose storage to | |
748 | * retrieve the tool from. | |
749 | */ | |
750 | private void populateWithPermTools(List<ToolData> tools, Context context, | |
751 | PipelineData pipelineData, User user) | |
752 | { | |
753 | // Iterate the tools | |
754 | 2 | for (Iterator<ToolData> it = tools.iterator(); it.hasNext();) |
755 | { | |
756 | 0 | ToolData toolData = it.next(); |
757 | try | |
758 | { | |
759 | // ensure that tool is created only once for a user | |
760 | // by synchronizing against the user object | |
761 | 0 | synchronized (user) |
762 | { | |
763 | // first try and fetch the tool from the user's | |
764 | // hashtable | |
765 | 0 | Object tool = user.getPerm(toolData.toolClassName); |
766 | ||
767 | 0 | if (tool == null) |
768 | { | |
769 | // if not there, an instance must be fetched from | |
770 | // the pool | |
771 | 0 | tool = pool.getInstance(toolData.toolClass); |
772 | ||
773 | // session tools are init'd with the User object | |
774 | 0 | initTool(tool, user); |
775 | ||
776 | // store the newly created tool in the user's hashtable | |
777 | 0 | user.setPerm(toolData.toolClassName, tool); |
778 | } | |
779 | ||
780 | // *NOT* else | |
781 | 0 | if(tool != null) |
782 | { | |
783 | // This is a semantics change. In the old | |
784 | // Turbine, Session tools were initialized and | |
785 | // then refreshed every time they were pulled | |
786 | // into the context if "refreshToolsPerRequest" | |
787 | // was wanted. | |
788 | // | |
789 | // RunDataApplicationTools now have a parameter | |
790 | // for refresh. If it is not refreshed immediately | |
791 | // after init(), the parameter value will be undefined | |
792 | // until the 2nd run. So we refresh all the session | |
793 | // tools on every run, even if we just init'ed it. | |
794 | // | |
795 | ||
796 | 0 | if (refreshToolsPerRequest) |
797 | { | |
798 | 0 | refreshTool(tool, pipelineData); |
799 | } | |
800 | ||
801 | // put the tool in the context | |
802 | 0 | log.debug("Adding " + tool + " to ctx as " |
803 | + toolData.toolName); | |
804 | 0 | log.warn("Persistent scope tools are deprecated."); |
805 | 0 | context.put(toolData.toolName, tool); |
806 | } | |
807 | else | |
808 | { | |
809 | 0 | log.info("Tool " + toolData.toolName |
810 | + " was null, skipping it."); | |
811 | } | |
812 | 0 | } |
813 | } | |
814 | 0 | catch (Exception e) |
815 | { | |
816 | 0 | log.error("Could not instantiate perm tool " |
817 | + toolData.toolName + " from a " | |
818 | + toolData.toolClassName + " object", e); | |
819 | 0 | } |
820 | 0 | } |
821 | 2 | } |
822 | ||
823 | /** | |
824 | * Populate the given context with the perm-scoped tools. | |
825 | * | |
826 | * @param tools The list of tools with which to populate the | |
827 | * session. | |
828 | * @param context The context to populate. | |
829 | * @param pipelineData The current RunData object | |
830 | * @param user The <code>User</code> object whose storage to | |
831 | * retrieve the tool from. | |
832 | */ | |
833 | private void populateWithPermTools(List<ToolData> tools, Context context, | |
834 | RunData data, User user) | |
835 | { | |
836 | // Iterate the tools | |
837 | 0 | for (Iterator<ToolData> it = tools.iterator(); it.hasNext();) |
838 | { | |
839 | 0 | ToolData toolData = it.next(); |
840 | try | |
841 | { | |
842 | // ensure that tool is created only once for a user | |
843 | // by synchronizing against the user object | |
844 | 0 | synchronized (user) |
845 | { | |
846 | // first try and fetch the tool from the user's | |
847 | // hashtable | |
848 | 0 | Object tool = user.getPerm(toolData.toolClassName); |
849 | ||
850 | 0 | if (tool == null) |
851 | { | |
852 | // if not there, an instance must be fetched from | |
853 | // the pool | |
854 | 0 | tool = pool.getInstance(toolData.toolClass); |
855 | ||
856 | // session tools are init'd with the User object | |
857 | 0 | initTool(tool, user); |
858 | ||
859 | // store the newly created tool in the user's hashtable | |
860 | 0 | user.setPerm(toolData.toolClassName, tool); |
861 | } | |
862 | ||
863 | // *NOT* else | |
864 | 0 | if(tool != null) |
865 | { | |
866 | // This is a semantics change. In the old | |
867 | // Turbine, Session tools were initialized and | |
868 | // then refreshed every time they were pulled | |
869 | // into the context if "refreshToolsPerRequest" | |
870 | // was wanted. | |
871 | // | |
872 | // RunDataApplicationTools now have a parameter | |
873 | // for refresh. If it is not refreshed immediately | |
874 | // after init(), the parameter value will be undefined | |
875 | // until the 2nd run. So we refresh all the session | |
876 | // tools on every run, even if we just init'ed it. | |
877 | // | |
878 | ||
879 | 0 | if (refreshToolsPerRequest) |
880 | { | |
881 | 0 | refreshTool(tool, data); |
882 | } | |
883 | ||
884 | // put the tool in the context | |
885 | 0 | log.debug("Adding " + tool + " to ctx as " |
886 | + toolData.toolName); | |
887 | 0 | log.warn("Persistent scope tools are deprecated."); |
888 | 0 | context.put(toolData.toolName, tool); |
889 | } | |
890 | else | |
891 | { | |
892 | 0 | log.info("Tool " + toolData.toolName |
893 | + " was null, skipping it."); | |
894 | } | |
895 | 0 | } |
896 | } | |
897 | 0 | catch (Exception e) |
898 | { | |
899 | 0 | log.error("Could not instantiate perm tool " |
900 | + toolData.toolName + " from a " | |
901 | + toolData.toolClassName + " object", e); | |
902 | 0 | } |
903 | 0 | } |
904 | 0 | } |
905 | ||
906 | ||
907 | ||
908 | /** | |
909 | * Return the absolute path to the resources directory | |
910 | * used by the application tools. | |
911 | * | |
912 | * @return the absolute path of the resources directory | |
913 | */ | |
914 | @Override | |
915 | public String getAbsolutePathToResourcesDirectory() | |
916 | { | |
917 | 0 | return Turbine.getRealPath(resourcesDirectory); |
918 | } | |
919 | ||
920 | /** | |
921 | * Return the resources directory. This is | |
922 | * relative to the web context. | |
923 | * | |
924 | * @return the relative path of the resources directory | |
925 | */ | |
926 | @Override | |
927 | public String getResourcesDirectory() | |
928 | { | |
929 | 19 | return resourcesDirectory; |
930 | } | |
931 | ||
932 | /** | |
933 | * Refresh the global tools. We can | |
934 | * only refresh those tools that adhere to | |
935 | * ApplicationTool interface because we | |
936 | * know those types of tools have a refresh | |
937 | * method. | |
938 | */ | |
939 | private void refreshGlobalTools() | |
940 | { | |
941 | 10 | if (globalTools != null) |
942 | { | |
943 | 10 | for (ToolData toolData : globalTools) |
944 | { | |
945 | 10 | Object tool = globalContext.get(toolData.toolName); |
946 | 10 | refreshTool(tool, null); |
947 | 10 | } |
948 | } | |
949 | 10 | } |
950 | ||
951 | /** | |
952 | * Release the request-scope tool instances in the | |
953 | * given Context back to the pool | |
954 | * | |
955 | * @param context the Velocity Context to release tools from | |
956 | */ | |
957 | @Override | |
958 | public void releaseTools(Context context) | |
959 | { | |
960 | // only the request tools can be released - other scoped | |
961 | // tools will have continuing references to them | |
962 | 2 | releaseTools(context, requestTools); |
963 | 2 | } |
964 | ||
965 | /** | |
966 | * Release the given list of tools from the context back | |
967 | * to the pool | |
968 | * | |
969 | * @param context the Context containing the tools | |
970 | * @param tools a List of ToolData objects | |
971 | */ | |
972 | private void releaseTools(Context context, List<ToolData> tools) | |
973 | { | |
974 | 2 | if (tools != null) |
975 | { | |
976 | 2 | for (ToolData toolData : tools) |
977 | { | |
978 | 10 | Object tool = context.remove(toolData.toolName); |
979 | ||
980 | 10 | if (tool != null) |
981 | { | |
982 | 10 | pool.putInstance(tool); |
983 | } | |
984 | 10 | } |
985 | } | |
986 | 2 | } |
987 | ||
988 | /** | |
989 | * Initialized a given Tool with the passed init Object | |
990 | * | |
991 | * @param tool A Tool Object | |
992 | * @param param The Init Parameter | |
993 | * | |
994 | * @throws Exception If anything went wrong. | |
995 | */ | |
996 | private void initTool(Object tool, Object param) | |
997 | throws Exception | |
998 | { | |
999 | 73 | AnnotationProcessor.process(tool); |
1000 | ||
1001 | 73 | if (param instanceof PipelineData) |
1002 | { | |
1003 | 45 | if (tool instanceof PipelineDataApplicationTool) |
1004 | { | |
1005 | 0 | ((PipelineDataApplicationTool) tool).init(param); |
1006 | } | |
1007 | 45 | else if (tool instanceof RunDataApplicationTool) |
1008 | { | |
1009 | 0 | RunData data = getRunData((PipelineData)param); |
1010 | 0 | ((RunDataApplicationTool) tool).init(data); |
1011 | 0 | } |
1012 | 45 | else if (tool instanceof ApplicationTool) |
1013 | { | |
1014 | 45 | RunData data = getRunData((PipelineData)param); |
1015 | 45 | ((ApplicationTool) tool).init(data); |
1016 | 45 | } |
1017 | } | |
1018 | else | |
1019 | { | |
1020 | 28 | if (tool instanceof PipelineDataApplicationTool) |
1021 | { | |
1022 | 0 | ((PipelineDataApplicationTool) tool).init(param); |
1023 | } | |
1024 | 28 | else if (tool instanceof RunDataApplicationTool) |
1025 | { | |
1026 | 0 | ((RunDataApplicationTool) tool).init(param); |
1027 | } | |
1028 | 28 | else if (tool instanceof ApplicationTool) |
1029 | { | |
1030 | 28 | ((ApplicationTool) tool).init(param); |
1031 | } | |
1032 | } | |
1033 | 73 | } |
1034 | ||
1035 | /** | |
1036 | * Refresh a given Tool. | |
1037 | * | |
1038 | * @param tool A Tool Object | |
1039 | * @param pipelineData The current RunData Object | |
1040 | */ | |
1041 | private void refreshTool(Object tool, Object dataObject) | |
1042 | { | |
1043 | 19 | RunData data = null; |
1044 | 19 | PipelineData pipelineData = null; |
1045 | 19 | if (dataObject instanceof PipelineData) |
1046 | { | |
1047 | 9 | pipelineData = (PipelineData)dataObject; |
1048 | 9 | data = getRunData(pipelineData); |
1049 | 9 | if (tool instanceof PipelineDataApplicationTool) |
1050 | { | |
1051 | 0 | ((PipelineDataApplicationTool) tool).refresh(pipelineData); |
1052 | } | |
1053 | } | |
1054 | 19 | if (tool instanceof ApplicationTool) |
1055 | { | |
1056 | 19 | ((ApplicationTool) tool).refresh(); |
1057 | } | |
1058 | 0 | else if (tool instanceof RunDataApplicationTool) |
1059 | { | |
1060 | 0 | ((RunDataApplicationTool) tool).refresh(data); |
1061 | } | |
1062 | 19 | } |
1063 | ||
1064 | private RunData getRunData(PipelineData pipelineData) | |
1065 | { | |
1066 | 54 | if(!(pipelineData instanceof RunData)){ |
1067 | 0 | throw new RuntimeException("Can't cast to rundata from pipeline data."); |
1068 | } | |
1069 | 54 | return (RunData)pipelineData; |
1070 | } | |
1071 | } |