1 package org.apache.turbine.services.pull;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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.turbine.Turbine;
33 import org.apache.turbine.om.security.User;
34 import org.apache.turbine.pipeline.PipelineData;
35 import org.apache.turbine.services.InitializationException;
36 import org.apache.turbine.services.TurbineBaseService;
37 import org.apache.turbine.services.TurbineServices;
38 import org.apache.turbine.services.security.TurbineSecurity;
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121 public class TurbinePullService
122 extends TurbineBaseService
123 implements PullService
124 {
125
126 private static Log log = LogFactory.getLog(TurbinePullService.class);
127
128
129 private PoolService pool = null;
130
131
132 private VelocityService velocity = null;
133
134
135
136
137
138
139
140
141
142 private Context globalContext;
143
144
145
146
147
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 {
157 this.toolName = toolName;
158 this.toolClassName = toolClassName;
159 this.toolClass = toolClass;
160 }
161 }
162
163
164 private List<ToolData> globalTools;
165
166
167 private List<ToolData> requestTools;
168
169
170 private List<ToolData> sessionTools;
171
172
173 private List<ToolData> authorizedTools;
174
175
176 private List<ToolData> persistentTools;
177
178
179 private String resourcesDirectory;
180
181
182 private boolean refreshToolsPerRequest = false;
183
184
185
186
187 @Override
188 public void init()
189 throws InitializationException
190 {
191 try
192 {
193 pool = (PoolService)TurbineServices.getInstance().getService(PoolService.ROLE);
194
195 if (pool == null)
196 {
197 throw new InitializationException("Pull Service requires"
198 + " configured Pool Service!");
199 }
200
201 initPullService();
202
203
204
205 setInit(true);
206
207
208 velocity = TurbineVelocity.getService();
209
210 if (velocity != null)
211 {
212 initPullTools();
213 }
214 else
215 {
216 log.info("Velocity Service not configured, skipping pull tools!");
217 }
218 }
219 catch (Exception e)
220 {
221 throw new InitializationException(
222 "TurbinePullService failed to initialize", e);
223 }
224 }
225
226
227
228
229
230
231 private void initPullService()
232 throws Exception
233 {
234
235 Configuration conf = getConfiguration();
236
237
238
239 resourcesDirectory = conf.getString(
240 TOOL_RESOURCES_DIR_KEY,
241 TOOL_RESOURCES_DIR_DEFAULT);
242
243
244
245 refreshToolsPerRequest =
246 conf.getBoolean(
247 TOOLS_PER_REQUEST_REFRESH_KEY,
248 TOOLS_PER_REQUEST_REFRESH_DEFAULT);
249
250
251
252 if (refreshToolsPerRequest)
253 {
254 log.info("Pull Model tools will "
255 + "be refreshed on a per request basis.");
256 }
257 }
258
259
260
261
262
263
264
265
266
267 private void initPullTools()
268 throws Exception
269 {
270
271
272
273
274 Configuration conf = Turbine.getConfiguration();
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290 log.debug("Global Tools:");
291 globalTools = getTools(conf.subset(GLOBAL_TOOL));
292 log.debug("Request Tools:");
293 requestTools = getTools(conf.subset(REQUEST_TOOL));
294 log.debug("Session Tools:");
295 sessionTools = getTools(conf.subset(SESSION_TOOL));
296 log.debug("Authorized Tools:");
297 authorizedTools = getTools(conf.subset(AUTHORIZED_TOOL));
298 log.debug("Persistent Tools:");
299 persistentTools = getTools(conf.subset(PERSISTENT_TOOL));
300
301
302
303
304
305
306 globalContext = velocity.getNewContext();
307
308 populateWithGlobalTools(globalContext);
309 }
310
311
312
313
314
315
316
317 @SuppressWarnings("unchecked")
318 private List<ToolData> getTools(Configuration toolConfig)
319 {
320 List<ToolData> tools = new ArrayList<ToolData>();
321
322
323
324 if (toolConfig == null)
325 {
326 return tools;
327 }
328
329 for (Iterator<String> it = toolConfig.getKeys(); it.hasNext();)
330 {
331 String toolName = it.next();
332 String toolClassName = toolConfig.getString(toolName);
333
334 try
335 {
336
337 Class<ApplicationTool> toolClass = (Class<ApplicationTool>) Class.forName(toolClassName);
338
339
340 tools.add(new ToolData(toolName, toolClassName, toolClass));
341
342 log.info("Tool " + toolClassName
343 + " to add to the context as '$" + toolName + "'");
344 }
345 catch (Exception e)
346 {
347 log.error("Cannot instantiate tool class "
348 + toolClassName + ": ", e);
349 }
350 }
351
352 return tools;
353 }
354
355
356
357
358
359
360
361 public Context getGlobalContext()
362 {
363 if (refreshToolsPerRequest)
364 {
365 refreshGlobalTools();
366 }
367 return globalContext;
368 }
369
370
371
372
373
374
375
376
377
378
379 public void populateContext(Context context, RunData data)
380 {
381 populateWithRequestTools(context, data);
382
383
384
385
386
387
388
389
390
391
392
393 User user = data.getUser();
394
395
396
397
398
399
400 populateWithSessionTools(sessionTools, context, data, user);
401
402 if (!TurbineSecurity.isAnonymousUser(user))
403 {
404 if (user.hasLoggedIn())
405 {
406 populateWithSessionTools(authorizedTools, context, data, user);
407 populateWithPermTools(persistentTools, context, data, user);
408 }
409 }
410 }
411
412
413
414
415
416
417
418
419
420
421 public void populateContext(Context context, PipelineData pipelineData)
422 {
423
424
425 RunData data = (RunData)pipelineData;
426
427 populateWithRequestTools(context, pipelineData);
428
429
430
431
432
433
434
435
436
437
438 User user = data.getUser();
439
440
441
442
443
444
445 populateWithSessionTools(sessionTools, context, pipelineData, user);
446
447 if (!TurbineSecurity.isAnonymousUser(user))
448 {
449 if (user.hasLoggedIn())
450 {
451 populateWithSessionTools(authorizedTools, context, pipelineData, user);
452 populateWithPermTools(persistentTools, context, pipelineData, user);
453 }
454 }
455 }
456
457
458
459
460
461
462 private void populateWithGlobalTools(Context context)
463 {
464 for (Iterator<ToolData> it = globalTools.iterator(); it.hasNext();)
465 {
466 ToolData toolData = it.next();
467 try
468 {
469 Object tool = toolData.toolClass.newInstance();
470
471
472 initTool(tool, null);
473
474
475 context.put(toolData.toolName, tool);
476 }
477 catch (Exception e)
478 {
479 log.error("Could not instantiate global tool "
480 + toolData.toolName + " from a "
481 + toolData.toolClassName + " object", e);
482 }
483 }
484 }
485
486
487
488
489
490
491
492 private void populateWithRequestTools(Context context, RunData data)
493 {
494
495 for (Iterator<ToolData> it = requestTools.iterator(); it.hasNext();)
496 {
497 ToolData toolData = it.next();
498 try
499 {
500
501 Object tool = pool.getInstance(toolData.toolClass);
502
503
504 initTool(tool, data);
505
506
507 context.put(toolData.toolName, tool);
508 }
509 catch (Exception e)
510 {
511 log.error("Could not instantiate request tool "
512 + toolData.toolName + " from a "
513 + toolData.toolClassName + " object", e);
514 }
515 }
516 }
517
518
519
520
521
522
523
524
525 private void populateWithRequestTools(Context context, PipelineData pipelineData)
526 {
527
528 for (Iterator<ToolData> it = requestTools.iterator(); it.hasNext();)
529 {
530 ToolData toolData = it.next();
531 try
532 {
533
534 Object tool = pool.getInstance(toolData.toolClass);
535
536 initTool(tool, pipelineData);
537
538
539 context.put(toolData.toolName, tool);
540 }
541 catch (Exception e)
542 {
543 log.error("Could not instantiate request tool "
544 + toolData.toolName + " from a "
545 + toolData.toolClassName + " object", e);
546 }
547 }
548 }
549
550
551
552
553
554
555
556
557
558
559
560 @SuppressWarnings({ "unused", "null" })
561 private void populateWithSessionTools(List<ToolData> tools, Context context,
562 PipelineData pipelineData, User user)
563 {
564
565
566 RunData runData = (RunData)pipelineData;
567
568 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
569 {
570 ToolData toolData = it.next();
571 try
572 {
573
574
575 synchronized (runData.getSession())
576 {
577
578
579 Object tool = runData.getSession().getAttribute(
580 SESSION_TOOLS_ATTRIBUTE_PREFIX
581 + toolData.toolClassName);
582
583 if (tool == null)
584 {
585
586
587 tool = pool.getInstance(toolData.toolClass);
588
589
590 initTool(tool, user);
591
592
593 runData.getSession().setAttribute(
594 SESSION_TOOLS_ATTRIBUTE_PREFIX
595 + tool.getClass().getName(), tool);
596 }
597
598
599 if(tool != null)
600 {
601
602
603
604
605
606
607
608
609
610
611
612
613
614 if (refreshToolsPerRequest)
615 {
616 refreshTool(tool, pipelineData);
617 }
618
619
620 log.debug("Adding " + tool + " to ctx as "
621 + toolData.toolName);
622 context.put(toolData.toolName, tool);
623 }
624 else
625 {
626 log.info("Tool " + toolData.toolName
627 + " was null, skipping it.");
628 }
629 }
630 }
631 catch (Exception e)
632 {
633 log.error("Could not instantiate session tool "
634 + toolData.toolName + " from a "
635 + toolData.toolClassName + " object", e);
636 }
637 }
638 }
639
640
641
642
643
644
645
646
647
648
649
650 @SuppressWarnings({ "unused", "null" })
651 private void populateWithSessionTools(List<ToolData> tools, Context context,
652 RunData data, User user)
653 {
654
655 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
656 {
657 ToolData toolData = it.next();
658 try
659 {
660
661
662 synchronized (data.getSession())
663 {
664
665
666 Object tool = data.getSession().getAttribute(
667 SESSION_TOOLS_ATTRIBUTE_PREFIX
668 + toolData.toolClassName);
669
670 if (tool == null)
671 {
672
673
674 tool = pool.getInstance(toolData.toolClass);
675
676
677 initTool(tool, user);
678
679
680 data.getSession().setAttribute(
681 SESSION_TOOLS_ATTRIBUTE_PREFIX
682 + tool.getClass().getName(), tool);
683 }
684
685
686 if(tool != null)
687 {
688
689
690
691
692
693
694
695
696
697
698
699
700
701 if (refreshToolsPerRequest)
702 {
703 refreshTool(tool, data);
704 }
705
706
707 log.debug("Adding " + tool + " to ctx as "
708 + toolData.toolName);
709 context.put(toolData.toolName, tool);
710 }
711 else
712 {
713 log.info("Tool " + toolData.toolName
714 + " was null, skipping it.");
715 }
716 }
717 }
718 catch (Exception e)
719 {
720 log.error("Could not instantiate session tool "
721 + toolData.toolName + " from a "
722 + toolData.toolClassName + " object", e);
723 }
724 }
725 }
726
727
728
729
730
731
732
733
734
735
736
737
738
739 private void populateWithPermTools(List<ToolData> tools, Context context,
740 PipelineData pipelineData, User user)
741 {
742
743 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
744 {
745 ToolData toolData = it.next();
746 try
747 {
748
749
750 synchronized (user)
751 {
752
753
754 Object tool = user.getPerm(toolData.toolClassName);
755
756 if (tool == null)
757 {
758
759
760 tool = pool.getInstance(toolData.toolClass);
761
762
763 initTool(tool, user);
764
765
766 user.setPerm(toolData.toolClassName, tool);
767 }
768
769
770 if(tool != null)
771 {
772
773
774
775
776
777
778
779
780
781
782
783
784
785 if (refreshToolsPerRequest)
786 {
787 refreshTool(tool, pipelineData);
788 }
789
790
791 log.debug("Adding " + tool + " to ctx as "
792 + toolData.toolName);
793 log.warn("Persistent scope tools are deprecated.");
794 context.put(toolData.toolName, tool);
795 }
796 else
797 {
798 log.info("Tool " + toolData.toolName
799 + " was null, skipping it.");
800 }
801 }
802 }
803 catch (Exception e)
804 {
805 log.error("Could not instantiate perm tool "
806 + toolData.toolName + " from a "
807 + toolData.toolClassName + " object", e);
808 }
809 }
810 }
811
812
813
814
815
816
817
818
819
820
821
822 private void populateWithPermTools(List<ToolData> tools, Context context,
823 RunData data, User user)
824 {
825
826 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
827 {
828 ToolData toolData = it.next();
829 try
830 {
831
832
833 synchronized (user)
834 {
835
836
837 Object tool = user.getPerm(toolData.toolClassName);
838
839 if (tool == null)
840 {
841
842
843 tool = pool.getInstance(toolData.toolClass);
844
845
846 initTool(tool, user);
847
848
849 user.setPerm(toolData.toolClassName, tool);
850 }
851
852
853 if(tool != null)
854 {
855
856
857
858
859
860
861
862
863
864
865
866
867
868 if (refreshToolsPerRequest)
869 {
870 refreshTool(tool, data);
871 }
872
873
874 log.debug("Adding " + tool + " to ctx as "
875 + toolData.toolName);
876 log.warn("Persistent scope tools are deprecated.");
877 context.put(toolData.toolName, tool);
878 }
879 else
880 {
881 log.info("Tool " + toolData.toolName
882 + " was null, skipping it.");
883 }
884 }
885 }
886 catch (Exception e)
887 {
888 log.error("Could not instantiate perm tool "
889 + toolData.toolName + " from a "
890 + toolData.toolClassName + " object", e);
891 }
892 }
893 }
894
895
896
897
898
899
900
901
902
903 public String getAbsolutePathToResourcesDirectory()
904 {
905 return Turbine.getRealPath(resourcesDirectory);
906 }
907
908
909
910
911
912
913
914 public String getResourcesDirectory()
915 {
916 return resourcesDirectory;
917 }
918
919
920
921
922
923
924
925
926 private void refreshGlobalTools()
927 {
928 for (Iterator<ToolData> it = globalTools.iterator(); it.hasNext();)
929 {
930 ToolData toolData = it.next();
931 Object tool = globalContext.get(toolData.toolName);
932 refreshTool(tool, null);
933 }
934 }
935
936
937
938
939
940
941
942 public void releaseTools(Context context)
943 {
944
945
946 releaseTools(context, requestTools);
947 }
948
949
950
951
952
953
954
955
956 private void releaseTools(Context context, List<ToolData> tools)
957 {
958 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
959 {
960 ToolData toolData = it.next();
961 Object tool = context.remove(toolData.toolName);
962
963 if (tool != null)
964 {
965 pool.putInstance(tool);
966 }
967 }
968 }
969
970
971
972
973
974
975
976
977
978 private void initTool(Object tool, Object param)
979 throws Exception
980 {
981 if (param instanceof PipelineData)
982 {
983 if (tool instanceof PipelineDataApplicationTool)
984 {
985 ((PipelineDataApplicationTool) tool).init(param);
986 }
987 else if (tool instanceof RunDataApplicationTool)
988 {
989 RunData data = getRunData((PipelineData)param);
990 ((RunDataApplicationTool) tool).init(data);
991 }
992 else if (tool instanceof ApplicationTool)
993 {
994 RunData data = getRunData((PipelineData)param);
995 ((ApplicationTool) tool).init(data);
996 }
997 }
998 else
999 {
1000 if (tool instanceof PipelineDataApplicationTool)
1001 {
1002 ((PipelineDataApplicationTool) tool).init(param);
1003 }
1004 else if (tool instanceof RunDataApplicationTool)
1005 {
1006 ((RunDataApplicationTool) tool).init(param);
1007 }
1008 else if (tool instanceof ApplicationTool)
1009 {
1010 ((ApplicationTool) tool).init(param);
1011 }
1012 }
1013 }
1014
1015
1016
1017
1018
1019
1020
1021 private void refreshTool(Object tool, Object dataObject)
1022 {
1023 RunData data = null;
1024 PipelineData pipelineData = null;
1025 if (dataObject instanceof PipelineData)
1026 {
1027 pipelineData = (PipelineData)dataObject;
1028 data = getRunData(pipelineData);
1029 if (tool instanceof PipelineDataApplicationTool)
1030 {
1031 ((PipelineDataApplicationTool) tool).refresh(pipelineData);
1032 }
1033 }
1034 if (tool instanceof ApplicationTool)
1035 {
1036 ((ApplicationTool) tool).refresh();
1037 }
1038 else if (tool instanceof RunDataApplicationTool)
1039 {
1040 ((RunDataApplicationTool) tool).refresh(data);
1041 }
1042 }
1043
1044 private RunData getRunData(PipelineData pipelineData)
1045 {
1046 if(!(pipelineData instanceof RunData)){
1047 throw new RuntimeException("Can't cast to rundata from pipeline data.");
1048 }
1049 return (RunData)pipelineData;
1050 }
1051 }