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.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
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 = (VelocityService)TurbineServices.getInstance().getService(VelocityService.SERVICE_NAME);
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("TurbinePullService failed to initialize", e);
222 }
223 }
224
225
226
227
228
229
230 private void initPullService()
231 throws Exception
232 {
233
234 Configuration conf = getConfiguration();
235
236
237
238 resourcesDirectory = conf.getString(
239 TOOL_RESOURCES_DIR_KEY,
240 TOOL_RESOURCES_DIR_DEFAULT);
241
242
243
244 refreshToolsPerRequest =
245 conf.getBoolean(
246 TOOLS_PER_REQUEST_REFRESH_KEY,
247 TOOLS_PER_REQUEST_REFRESH_DEFAULT);
248
249
250
251 if (refreshToolsPerRequest)
252 {
253 log.info("Pull Model tools will "
254 + "be refreshed on a per request basis.");
255 }
256 }
257
258
259
260
261
262
263
264
265
266 private void initPullTools()
267 throws Exception
268 {
269
270
271
272
273 Configuration conf = Turbine.getConfiguration();
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289 log.debug("Global Tools:");
290 globalTools = getTools(conf.subset(GLOBAL_TOOL));
291 log.debug("Request Tools:");
292 requestTools = getTools(conf.subset(REQUEST_TOOL));
293 log.debug("Session Tools:");
294 sessionTools = getTools(conf.subset(SESSION_TOOL));
295 log.debug("Authorized Tools:");
296 authorizedTools = getTools(conf.subset(AUTHORIZED_TOOL));
297 log.debug("Persistent Tools:");
298 persistentTools = getTools(conf.subset(PERSISTENT_TOOL));
299
300
301
302
303
304
305 globalContext = velocity.getNewContext();
306
307 populateWithGlobalTools(globalContext);
308 }
309
310
311
312
313
314
315
316 @SuppressWarnings("unchecked")
317 private List<ToolData> getTools(Configuration toolConfig)
318 {
319 List<ToolData> tools = new ArrayList<ToolData>();
320
321
322
323 if (toolConfig == null)
324 {
325 return tools;
326 }
327
328 for (Iterator<String> it = toolConfig.getKeys(); it.hasNext();)
329 {
330 String toolName = it.next();
331 String toolClassName = toolConfig.getString(toolName);
332
333 try
334 {
335
336 Class<ApplicationTool> toolClass = (Class<ApplicationTool>) Class.forName(toolClassName);
337
338
339 tools.add(new ToolData(toolName, toolClassName, toolClass));
340
341 log.info("Tool " + toolClassName
342 + " to add to the context as '$" + toolName + "'");
343 }
344
345 catch (Throwable 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 @Override
362 public Context getGlobalContext()
363 {
364 if (refreshToolsPerRequest)
365 {
366 refreshGlobalTools();
367 }
368 return globalContext;
369 }
370
371
372
373
374
375
376
377
378
379
380 @Override
381 public void populateContext(Context context, RunData data)
382 {
383 populateWithRequestTools(context, data);
384
385
386
387
388
389
390
391
392
393
394
395 User user = data.getUser();
396
397
398
399
400
401
402 populateWithSessionTools(sessionTools, context, data, user);
403
404 TurbineUserManager userManager =
405 (TurbineUserManager)TurbineServices
406 .getInstance()
407 .getService(TurbineUserManager.ROLE);
408
409 if (!userManager.isAnonymousUser(user))
410 {
411 if (user.hasLoggedIn())
412 {
413 populateWithSessionTools(authorizedTools, context, data, user);
414 populateWithPermTools(persistentTools, context, data, user);
415 }
416 }
417 }
418
419
420
421
422
423
424
425
426
427
428 @Override
429 public void populateContext(Context context, PipelineData pipelineData)
430 {
431
432
433 RunData data = (RunData)pipelineData;
434
435 populateWithRequestTools(context, pipelineData);
436
437
438
439
440
441
442
443
444
445
446 User user = data.getUser();
447
448
449
450
451
452
453 populateWithSessionTools(sessionTools, context, pipelineData, user);
454
455 TurbineUserManager userManager =
456 (TurbineUserManager)TurbineServices
457 .getInstance()
458 .getService(TurbineUserManager.ROLE);
459
460 if (!userManager.isAnonymousUser(user))
461 {
462 if (user.hasLoggedIn())
463 {
464 populateWithSessionTools(authorizedTools, context, pipelineData, user);
465 populateWithPermTools(persistentTools, context, pipelineData, user);
466 }
467 }
468 }
469
470
471
472
473
474
475 private void populateWithGlobalTools(Context context)
476 {
477 for (Iterator<ToolData> it = globalTools.iterator(); it.hasNext();)
478 {
479 ToolData toolData = it.next();
480 try
481 {
482 Object tool = toolData.toolClass.newInstance();
483
484
485 initTool(tool, null);
486
487
488 context.put(toolData.toolName, tool);
489 }
490 catch (Exception e)
491 {
492 log.error("Could not instantiate global tool "
493 + toolData.toolName + " from a "
494 + toolData.toolClassName + " object", e);
495 }
496 }
497 }
498
499
500
501
502
503
504
505 private void populateWithRequestTools(Context context, RunData data)
506 {
507
508 for (Iterator<ToolData> it = requestTools.iterator(); it.hasNext();)
509 {
510 ToolData toolData = it.next();
511 try
512 {
513
514 Object tool = pool.getInstance(toolData.toolClass);
515
516
517 initTool(tool, data);
518
519
520 context.put(toolData.toolName, tool);
521 }
522 catch (Exception e)
523 {
524 log.error("Could not instantiate request tool "
525 + toolData.toolName + " from a "
526 + toolData.toolClassName + " object", e);
527 }
528 }
529 }
530
531
532
533
534
535
536
537
538 private void populateWithRequestTools(Context context, PipelineData pipelineData)
539 {
540
541 for (Iterator<ToolData> it = requestTools.iterator(); it.hasNext();)
542 {
543 ToolData toolData = it.next();
544 try
545 {
546
547 Object tool = pool.getInstance(toolData.toolClass);
548
549 initTool(tool, pipelineData);
550
551
552 context.put(toolData.toolName, tool);
553 }
554 catch (Exception e)
555 {
556 log.error("Could not instantiate request tool "
557 + toolData.toolName + " from a "
558 + toolData.toolClassName + " object", e);
559 }
560 }
561 }
562
563
564
565
566
567
568
569
570
571
572
573 private void populateWithSessionTools(List<ToolData> tools, Context context,
574 PipelineData pipelineData, User user)
575 {
576
577
578 RunData runData = (RunData)pipelineData;
579
580 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
581 {
582 ToolData toolData = it.next();
583 try
584 {
585
586
587 synchronized (runData.getSession())
588 {
589
590
591 Object tool = runData.getSession().getAttribute(
592 SESSION_TOOLS_ATTRIBUTE_PREFIX
593 + toolData.toolClassName);
594
595 if (tool == null)
596 {
597
598
599 tool = pool.getInstance(toolData.toolClass);
600
601
602 initTool(tool, user);
603 }
604
605
606 if(tool != null)
607 {
608
609 runData.getSession().setAttribute(
610 SESSION_TOOLS_ATTRIBUTE_PREFIX
611 + tool.getClass().getName(), tool);
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626 if (refreshToolsPerRequest)
627 {
628 refreshTool(tool, pipelineData);
629 }
630
631
632 log.debug("Adding " + tool + " to ctx as "
633 + toolData.toolName);
634 context.put(toolData.toolName, tool);
635 }
636 else
637 {
638 log.info("Tool " + toolData.toolName
639 + " was null, skipping it.");
640 }
641 }
642 }
643 catch (Exception e)
644 {
645 log.error("Could not instantiate session tool "
646 + toolData.toolName + " from a "
647 + toolData.toolClassName + " object", e);
648 }
649 }
650 }
651
652
653
654
655
656
657
658
659
660
661
662 private void populateWithSessionTools(List<ToolData> tools, Context context,
663 RunData data, User user)
664 {
665
666 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
667 {
668 ToolData toolData = it.next();
669 try
670 {
671
672
673 synchronized (data.getSession())
674 {
675
676
677 Object tool = data.getSession().getAttribute(
678 SESSION_TOOLS_ATTRIBUTE_PREFIX
679 + toolData.toolClassName);
680
681 if (tool == null)
682 {
683
684
685 tool = pool.getInstance(toolData.toolClass);
686
687
688 initTool(tool, user);
689 }
690
691
692 if(tool != null)
693 {
694
695 data.getSession().setAttribute(
696 SESSION_TOOLS_ATTRIBUTE_PREFIX
697 + tool.getClass().getName(), tool);
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712 if (refreshToolsPerRequest)
713 {
714 refreshTool(tool, data);
715 }
716
717
718 log.debug("Adding " + tool + " to ctx as "
719 + toolData.toolName);
720 context.put(toolData.toolName, tool);
721 }
722 else
723 {
724 log.info("Tool " + toolData.toolName
725 + " was null, skipping it.");
726 }
727 }
728 }
729 catch (Exception e)
730 {
731 log.error("Could not instantiate session tool "
732 + toolData.toolName + " from a "
733 + toolData.toolClassName + " object", e);
734 }
735 }
736 }
737
738
739
740
741
742
743
744
745
746
747
748
749
750 private void populateWithPermTools(List<ToolData> tools, Context context,
751 PipelineData pipelineData, User user)
752 {
753
754 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
755 {
756 ToolData toolData = it.next();
757 try
758 {
759
760
761 synchronized (user)
762 {
763
764
765 Object tool = user.getPerm(toolData.toolClassName);
766
767 if (tool == null)
768 {
769
770
771 tool = pool.getInstance(toolData.toolClass);
772
773
774 initTool(tool, user);
775
776
777 user.setPerm(toolData.toolClassName, tool);
778 }
779
780
781 if(tool != null)
782 {
783
784
785
786
787
788
789
790
791
792
793
794
795
796 if (refreshToolsPerRequest)
797 {
798 refreshTool(tool, pipelineData);
799 }
800
801
802 log.debug("Adding " + tool + " to ctx as "
803 + toolData.toolName);
804 log.warn("Persistent scope tools are deprecated.");
805 context.put(toolData.toolName, tool);
806 }
807 else
808 {
809 log.info("Tool " + toolData.toolName
810 + " was null, skipping it.");
811 }
812 }
813 }
814 catch (Exception e)
815 {
816 log.error("Could not instantiate perm tool "
817 + toolData.toolName + " from a "
818 + toolData.toolClassName + " object", e);
819 }
820 }
821 }
822
823
824
825
826
827
828
829
830
831
832
833 private void populateWithPermTools(List<ToolData> tools, Context context,
834 RunData data, User user)
835 {
836
837 for (Iterator<ToolData> it = tools.iterator(); it.hasNext();)
838 {
839 ToolData toolData = it.next();
840 try
841 {
842
843
844 synchronized (user)
845 {
846
847
848 Object tool = user.getPerm(toolData.toolClassName);
849
850 if (tool == null)
851 {
852
853
854 tool = pool.getInstance(toolData.toolClass);
855
856
857 initTool(tool, user);
858
859
860 user.setPerm(toolData.toolClassName, tool);
861 }
862
863
864 if(tool != null)
865 {
866
867
868
869
870
871
872
873
874
875
876
877
878
879 if (refreshToolsPerRequest)
880 {
881 refreshTool(tool, data);
882 }
883
884
885 log.debug("Adding " + tool + " to ctx as "
886 + toolData.toolName);
887 log.warn("Persistent scope tools are deprecated.");
888 context.put(toolData.toolName, tool);
889 }
890 else
891 {
892 log.info("Tool " + toolData.toolName
893 + " was null, skipping it.");
894 }
895 }
896 }
897 catch (Exception e)
898 {
899 log.error("Could not instantiate perm tool "
900 + toolData.toolName + " from a "
901 + toolData.toolClassName + " object", e);
902 }
903 }
904 }
905
906
907
908
909
910
911
912
913
914 @Override
915 public String getAbsolutePathToResourcesDirectory()
916 {
917 return Turbine.getRealPath(resourcesDirectory);
918 }
919
920
921
922
923
924
925
926 @Override
927 public String getResourcesDirectory()
928 {
929 return resourcesDirectory;
930 }
931
932
933
934
935
936
937
938
939 private void refreshGlobalTools()
940 {
941 if (globalTools != null)
942 {
943 for (ToolData toolData : globalTools)
944 {
945 Object tool = globalContext.get(toolData.toolName);
946 refreshTool(tool, null);
947 }
948 }
949 }
950
951
952
953
954
955
956
957 @Override
958 public void releaseTools(Context context)
959 {
960
961
962 releaseTools(context, requestTools);
963 }
964
965
966
967
968
969
970
971
972 private void releaseTools(Context context, List<ToolData> tools)
973 {
974 if (tools != null)
975 {
976 for (ToolData toolData : tools)
977 {
978 Object tool = context.remove(toolData.toolName);
979
980 if (tool != null)
981 {
982 pool.putInstance(tool);
983 }
984 }
985 }
986 }
987
988
989
990
991
992
993
994
995
996 private void initTool(Object tool, Object param)
997 throws Exception
998 {
999 AnnotationProcessor.process(tool);
1000
1001 if (param instanceof PipelineData)
1002 {
1003 if (tool instanceof PipelineDataApplicationTool)
1004 {
1005 ((PipelineDataApplicationTool) tool).init(param);
1006 }
1007 else if (tool instanceof RunDataApplicationTool)
1008 {
1009 RunData data = getRunData((PipelineData)param);
1010 ((RunDataApplicationTool) tool).init(data);
1011 }
1012 else if (tool instanceof ApplicationTool)
1013 {
1014 RunData data = getRunData((PipelineData)param);
1015 ((ApplicationTool) tool).init(data);
1016 }
1017 }
1018 else
1019 {
1020 if (tool instanceof PipelineDataApplicationTool)
1021 {
1022 ((PipelineDataApplicationTool) tool).init(param);
1023 }
1024 else if (tool instanceof RunDataApplicationTool)
1025 {
1026 ((RunDataApplicationTool) tool).init(param);
1027 }
1028 else if (tool instanceof ApplicationTool)
1029 {
1030 ((ApplicationTool) tool).init(param);
1031 }
1032 }
1033 }
1034
1035
1036
1037
1038
1039
1040
1041 private void refreshTool(Object tool, Object dataObject)
1042 {
1043 RunData data = null;
1044 PipelineData pipelineData = null;
1045 if (dataObject instanceof PipelineData)
1046 {
1047 pipelineData = (PipelineData)dataObject;
1048 data = getRunData(pipelineData);
1049 if (tool instanceof PipelineDataApplicationTool)
1050 {
1051 ((PipelineDataApplicationTool) tool).refresh(pipelineData);
1052 }
1053 }
1054 if (tool instanceof ApplicationTool)
1055 {
1056 ((ApplicationTool) tool).refresh();
1057 }
1058 else if (tool instanceof RunDataApplicationTool)
1059 {
1060 ((RunDataApplicationTool) tool).refresh(data);
1061 }
1062 }
1063
1064 private RunData getRunData(PipelineData pipelineData)
1065 {
1066 if(!(pipelineData instanceof RunData)){
1067 throw new RuntimeException("Can't cast to rundata from pipeline data.");
1068 }
1069 return (RunData)pipelineData;
1070 }
1071 }