Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
TurbinePullService |
|
| 3.4782608695652173;3,478 | ||||
TurbinePullService$ToolData |
|
| 3.4782608695652173;3,478 |
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.om.security.User; | |
35 | import org.apache.turbine.pipeline.PipelineData; | |
36 | import org.apache.turbine.services.InitializationException; | |
37 | import org.apache.turbine.services.TurbineBaseService; | |
38 | import org.apache.turbine.services.TurbineServices; | |
39 | import org.apache.turbine.services.velocity.TurbineVelocity; | |
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 1706239 2015-10-01 13:18:35Z tv $ | |
120 | */ | |
121 | 30 | public class TurbinePullService |
122 | extends TurbineBaseService | |
123 | implements PullService | |
124 | { | |
125 | /** Logging */ | |
126 | 30 | private static Log log = LogFactory.getLog(TurbinePullService.class); |
127 | ||
128 | /** Reference to the pool service */ | |
129 | 30 | private PoolService pool = null; |
130 | ||
131 | /** Reference to the templating (nee Velocity) service */ | |
132 | 30 | 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 | 119 | { |
157 | 119 | this.toolName = toolName; |
158 | 119 | this.toolClassName = toolClassName; |
159 | 119 | this.toolClass = toolClass; |
160 | 119 | } |
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 | 30 | 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 | 37 | pool = (PoolService)TurbineServices.getInstance().getService(PoolService.ROLE); |
194 | ||
195 | 37 | if (pool == null) |
196 | { | |
197 | 0 | throw new InitializationException("Pull Service requires" |
198 | + " configured Pool Service!"); | |
199 | } | |
200 | ||
201 | 37 | 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 | 37 | setInit(true); |
206 | ||
207 | // Do _NOT_ move this before the setInit(true) | |
208 | 37 | velocity = TurbineVelocity.getService(); |
209 | ||
210 | 26 | if (velocity != null) |
211 | { | |
212 | 26 | 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( |
222 | "TurbinePullService failed to initialize", e); | |
223 | 26 | } |
224 | 26 | } |
225 | ||
226 | /** | |
227 | * Initialize the pull service | |
228 | * | |
229 | * @exception Exception A problem happened when starting up | |
230 | */ | |
231 | private void initPullService() | |
232 | throws Exception | |
233 | { | |
234 | // This is the per-service configuration, prefixed with services.PullService | |
235 | 37 | Configuration conf = getConfiguration(); |
236 | ||
237 | // Get the resources directory that is specificed | |
238 | // in the TR.props or default to "resources", relative to the webapp. | |
239 | 37 | resourcesDirectory = conf.getString( |
240 | TOOL_RESOURCES_DIR_KEY, | |
241 | TOOL_RESOURCES_DIR_DEFAULT); | |
242 | ||
243 | // Should we refresh the tool box on a per | |
244 | // request basis. | |
245 | 37 | refreshToolsPerRequest = |
246 | conf.getBoolean( | |
247 | TOOLS_PER_REQUEST_REFRESH_KEY, | |
248 | TOOLS_PER_REQUEST_REFRESH_DEFAULT); | |
249 | ||
250 | // Log the fact that the application tool box will | |
251 | // be refreshed on a per request basis. | |
252 | 37 | if (refreshToolsPerRequest) |
253 | { | |
254 | 28 | log.info("Pull Model tools will " |
255 | + "be refreshed on a per request basis."); | |
256 | } | |
257 | 37 | } |
258 | ||
259 | /** | |
260 | * Initialize the pull tools. At this point, the | |
261 | * service must be marked as initialized, because the | |
262 | * tools may call the methods of this service via the | |
263 | * static facade class TurbinePull. | |
264 | * | |
265 | * @exception Exception A problem happened when starting up | |
266 | */ | |
267 | private void initPullTools() | |
268 | throws Exception | |
269 | { | |
270 | // And for reasons I never really fully understood, | |
271 | // the tools directive is toplevel without the service | |
272 | // prefix. This is brain-damaged but for legacy reasons we | |
273 | // keep this. So this is the global turbine configuration: | |
274 | 26 | Configuration conf = Turbine.getConfiguration(); |
275 | ||
276 | // Grab each list of tools that are to be used (for global scope, | |
277 | // request scope, authorized scope, session scope and persistent | |
278 | // scope tools). They are specified respectively in the TR.props | |
279 | // like this: | |
280 | // | |
281 | // tool.global.ui = org.apache.turbine.util.pull.UIManager | |
282 | // tool.global.mm = org.apache.turbine.util.pull.MessageManager | |
283 | // | |
284 | // tool.request.link = org.apache.turbine.services.pull.tools.TemplateLink | |
285 | // | |
286 | // tool.session.basket = org.sample.util.ShoppingBasket; | |
287 | // | |
288 | // tool.persistent.ui = org.apache.turbine.services.pull.util.PersistentUIManager | |
289 | ||
290 | 26 | log.debug("Global Tools:"); |
291 | 26 | globalTools = getTools(conf.subset(GLOBAL_TOOL)); |
292 | 26 | log.debug("Request Tools:"); |
293 | 26 | requestTools = getTools(conf.subset(REQUEST_TOOL)); |
294 | 26 | log.debug("Session Tools:"); |
295 | 26 | sessionTools = getTools(conf.subset(SESSION_TOOL)); |
296 | 26 | log.debug("Authorized Tools:"); |
297 | 26 | authorizedTools = getTools(conf.subset(AUTHORIZED_TOOL)); |
298 | 26 | log.debug("Persistent Tools:"); |
299 | 26 | persistentTools = getTools(conf.subset(PERSISTENT_TOOL)); |
300 | ||
301 | // Create and populate the global context right now | |
302 | ||
303 | // This is unholy, because it entwines the VelocityService and | |
304 | // the Pull Service even further. However, there isn't much we can | |
305 | // do for the 2.3 release. Expect this to go post-2.3 | |
306 | 26 | globalContext = velocity.getNewContext(); |
307 | ||
308 | 26 | populateWithGlobalTools(globalContext); |
309 | 26 | } |
310 | ||
311 | /** | |
312 | * Retrieve the tool names and classes for the tools definied | |
313 | * in the configuration file with the prefix given. | |
314 | * | |
315 | * @param toolConfig The part of the configuration describing some tools | |
316 | */ | |
317 | @SuppressWarnings("unchecked") | |
318 | private List<ToolData> getTools(Configuration toolConfig) | |
319 | { | |
320 | 130 | List<ToolData> tools = new ArrayList<ToolData>(); |
321 | ||
322 | // There might not be any tools for this prefix | |
323 | // so return an empty list. | |
324 | 130 | if (toolConfig == null) |
325 | { | |
326 | 0 | return tools; |
327 | } | |
328 | ||
329 | 130 | for (Iterator<String> it = toolConfig.getKeys(); it.hasNext();) |
330 | { | |
331 | 119 | String toolName = it.next(); |
332 | 119 | String toolClassName = toolConfig.getString(toolName); |
333 | ||
334 | try | |
335 | { | |
336 | // Create an instance of the tool class. | |
337 | 119 | Class<ApplicationTool> toolClass = (Class<ApplicationTool>) Class.forName(toolClassName); |
338 | ||
339 | // Add the tool to the list being built. | |
340 | 119 | tools.add(new ToolData(toolName, toolClassName, toolClass)); |
341 | ||
342 | 119 | log.info("Tool " + toolClassName |
343 | + " to add to the context as '$" + toolName + "'"); | |
344 | } | |
345 | 0 | catch (Exception e) |
346 | { | |
347 | 0 | log.error("Cannot instantiate tool class " |
348 | + toolClassName + ": ", e); | |
349 | 119 | } |
350 | 119 | } |
351 | ||
352 | 130 | 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 | 26 | for (Iterator<ToolData> it = globalTools.iterator(); it.hasNext();) |
478 | { | |
479 | 17 | ToolData toolData = it.next(); |
480 | try | |
481 | { | |
482 | 17 | Object tool = toolData.toolClass.newInstance(); |
483 | ||
484 | // global tools are init'd with a null data parameter | |
485 | 17 | initTool(tool, null); |
486 | ||
487 | // put the tool in the context | |
488 | 17 | 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 | 17 | } |
496 | 17 | } |
497 | 26 | } |
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 | // hashtable | |
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 | 17 | 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 | for (Iterator<ToolData> it = globalTools.iterator(); it.hasNext();) |
942 | { | |
943 | 10 | ToolData toolData = it.next(); |
944 | 10 | Object tool = globalContext.get(toolData.toolName); |
945 | 10 | refreshTool(tool, null); |
946 | 10 | } |
947 | 10 | } |
948 | ||
949 | /** | |
950 | * Release the request-scope tool instances in the | |
951 | * given Context back to the pool | |
952 | * | |
953 | * @param context the Velocity Context to release tools from | |
954 | */ | |
955 | @Override | |
956 | public void releaseTools(Context context) | |
957 | { | |
958 | // only the request tools can be released - other scoped | |
959 | // tools will have continuing references to them | |
960 | 2 | releaseTools(context, requestTools); |
961 | 2 | } |
962 | ||
963 | /** | |
964 | * Release the given list of tools from the context back | |
965 | * to the pool | |
966 | * | |
967 | * @param context the Context containing the tools | |
968 | * @param tools a List of ToolData objects | |
969 | */ | |
970 | private void releaseTools(Context context, List<ToolData> tools) | |
971 | { | |
972 | 2 | for (Iterator<ToolData> it = tools.iterator(); it.hasNext();) |
973 | { | |
974 | 10 | ToolData toolData = it.next(); |
975 | 10 | Object tool = context.remove(toolData.toolName); |
976 | ||
977 | 10 | if (tool != null) |
978 | { | |
979 | 10 | pool.putInstance(tool); |
980 | } | |
981 | 10 | } |
982 | 2 | } |
983 | ||
984 | /** | |
985 | * Initialized a given Tool with the passed init Object | |
986 | * | |
987 | * @param tool A Tool Object | |
988 | * @param param The Init Parameter | |
989 | * | |
990 | * @throws Exception If anything went wrong. | |
991 | */ | |
992 | private void initTool(Object tool, Object param) | |
993 | throws Exception | |
994 | { | |
995 | 71 | if (param instanceof PipelineData) |
996 | { | |
997 | 45 | if (tool instanceof PipelineDataApplicationTool) |
998 | { | |
999 | 0 | ((PipelineDataApplicationTool) tool).init(param); |
1000 | } | |
1001 | 45 | else if (tool instanceof RunDataApplicationTool) |
1002 | { | |
1003 | 0 | RunData data = getRunData((PipelineData)param); |
1004 | 0 | ((RunDataApplicationTool) tool).init(data); |
1005 | 0 | } |
1006 | 45 | else if (tool instanceof ApplicationTool) |
1007 | { | |
1008 | 45 | RunData data = getRunData((PipelineData)param); |
1009 | 45 | ((ApplicationTool) tool).init(data); |
1010 | 45 | } |
1011 | } | |
1012 | else | |
1013 | { | |
1014 | 26 | if (tool instanceof PipelineDataApplicationTool) |
1015 | { | |
1016 | 0 | ((PipelineDataApplicationTool) tool).init(param); |
1017 | } | |
1018 | 26 | else if (tool instanceof RunDataApplicationTool) |
1019 | { | |
1020 | 0 | ((RunDataApplicationTool) tool).init(param); |
1021 | } | |
1022 | 26 | else if (tool instanceof ApplicationTool) |
1023 | { | |
1024 | 26 | ((ApplicationTool) tool).init(param); |
1025 | } | |
1026 | } | |
1027 | 71 | } |
1028 | ||
1029 | /** | |
1030 | * Refresh a given Tool. | |
1031 | * | |
1032 | * @param tool A Tool Object | |
1033 | * @param pipelineData The current RunData Object | |
1034 | */ | |
1035 | private void refreshTool(Object tool, Object dataObject) | |
1036 | { | |
1037 | 19 | RunData data = null; |
1038 | 19 | PipelineData pipelineData = null; |
1039 | 19 | if (dataObject instanceof PipelineData) |
1040 | { | |
1041 | 9 | pipelineData = (PipelineData)dataObject; |
1042 | 9 | data = getRunData(pipelineData); |
1043 | 9 | if (tool instanceof PipelineDataApplicationTool) |
1044 | { | |
1045 | 0 | ((PipelineDataApplicationTool) tool).refresh(pipelineData); |
1046 | } | |
1047 | } | |
1048 | 19 | if (tool instanceof ApplicationTool) |
1049 | { | |
1050 | 19 | ((ApplicationTool) tool).refresh(); |
1051 | } | |
1052 | 0 | else if (tool instanceof RunDataApplicationTool) |
1053 | { | |
1054 | 0 | ((RunDataApplicationTool) tool).refresh(data); |
1055 | } | |
1056 | 19 | } |
1057 | ||
1058 | private RunData getRunData(PipelineData pipelineData) | |
1059 | { | |
1060 | 54 | if(!(pipelineData instanceof RunData)){ |
1061 | 0 | throw new RuntimeException("Can't cast to rundata from pipeline data."); |
1062 | } | |
1063 | 54 | return (RunData)pipelineData; |
1064 | } | |
1065 | } |