Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
TurbinePipeline |
|
| 2.125;2,125 |
1 | package org.apache.turbine.pipeline; | |
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.io.IOException; | |
25 | ||
26 | import org.apache.turbine.annotation.AnnotationProcessor; | |
27 | import org.apache.turbine.util.TurbineException; | |
28 | ||
29 | /** | |
30 | * Flexible implementation of a {@link org.apache.turbine.pipeline.Pipeline}. | |
31 | * Originally based on code from Catalina and ideas from Apache httpd. | |
32 | * | |
33 | * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a> | |
34 | * @author <a href="mailto:jvanzyl@zenplex.com">Jason van Zyl</a> | |
35 | * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a> | |
36 | */ | |
37 | 12 | public class TurbinePipeline |
38 | implements Pipeline, ValveContext | |
39 | { | |
40 | /** | |
41 | * The "Turbine Classic" pipeline. | |
42 | */ | |
43 | public static final String CLASSIC_PIPELINE = | |
44 | "WEB-INF/conf/turbine-classic-pipeline.xml"; | |
45 | ||
46 | /** | |
47 | * Name of this pipeline. | |
48 | */ | |
49 | protected String name; | |
50 | ||
51 | /** | |
52 | * The set of Valves associated with this Pipeline. | |
53 | */ | |
54 | 12 | protected Valve[] valves = new Valve[0]; |
55 | ||
56 | /** | |
57 | * The per-thread execution state for processing through this | |
58 | * pipeline. The actual value is a java.lang.Integer object | |
59 | * containing the subscript into the <code>values</code> array, or | |
60 | * a subscript equal to <code>values.length</code> if the basic | |
61 | * Valve is currently being processed. | |
62 | */ | |
63 | 12 | protected ThreadLocal<Integer> state= new ThreadLocal<Integer>(); |
64 | ||
65 | /** | |
66 | * @see org.apache.turbine.pipeline.Pipeline#initialize() | |
67 | */ | |
68 | @Override | |
69 | public void initialize() | |
70 | throws Exception | |
71 | { | |
72 | 47 | if (state==null) |
73 | { | |
74 | 41 | state = new ThreadLocal<Integer>(); |
75 | } | |
76 | ||
77 | // Valve implementations are added to this Pipeline using the | |
78 | // Mapper. | |
79 | ||
80 | // Initialize the valves | |
81 | 422 | for (int i = 0; i < valves.length; i++) |
82 | { | |
83 | 375 | AnnotationProcessor.process(valves[i]); |
84 | 375 | valves[i].initialize(); |
85 | } | |
86 | 47 | } |
87 | ||
88 | /** | |
89 | * Set the name of this pipeline. | |
90 | * | |
91 | * @param name Name of this pipeline. | |
92 | */ | |
93 | public void setName(String name) | |
94 | { | |
95 | 0 | this.name = name; |
96 | 0 | } |
97 | ||
98 | /** | |
99 | * Get the name of this pipeline. | |
100 | * | |
101 | * @return String Name of this pipeline. | |
102 | */ | |
103 | public String getName() | |
104 | { | |
105 | 0 | return name; |
106 | } | |
107 | ||
108 | /** | |
109 | * @see org.apache.turbine.pipeline.Pipeline#addValve(Valve) | |
110 | */ | |
111 | @Override | |
112 | public void addValve(Valve valve) | |
113 | { | |
114 | // Add this Valve to the set associated with this Pipeline | |
115 | 13 | synchronized (valves) |
116 | { | |
117 | 13 | Valve[] results = new Valve[valves.length + 1]; |
118 | 13 | System.arraycopy(valves, 0, results, 0, valves.length); |
119 | 13 | results[valves.length] = valve; |
120 | 13 | valves = results; |
121 | 13 | } |
122 | 13 | } |
123 | ||
124 | /** | |
125 | * @see org.apache.turbine.pipeline.Pipeline#getValves() | |
126 | */ | |
127 | @Override | |
128 | public Valve[] getValves() | |
129 | { | |
130 | 3 | synchronized (valves) |
131 | { | |
132 | 3 | Valve[] results = new Valve[valves.length]; |
133 | 3 | System.arraycopy(valves, 0, results, 0, valves.length); |
134 | 3 | return results; |
135 | 0 | } |
136 | } | |
137 | ||
138 | /** | |
139 | * @see org.apache.turbine.pipeline.Pipeline#removeValve(Valve) | |
140 | */ | |
141 | @Override | |
142 | public void removeValve(Valve valve) | |
143 | { | |
144 | 0 | synchronized (valves) |
145 | { | |
146 | // Locate this Valve in our list | |
147 | 0 | int index = -1; |
148 | 0 | for (int i = 0; i < valves.length; i++) |
149 | { | |
150 | 0 | if (valve == valves[i]) |
151 | { | |
152 | 0 | index = i; |
153 | 0 | break; |
154 | } | |
155 | } | |
156 | 0 | if (index < 0) |
157 | { | |
158 | 0 | return; |
159 | } | |
160 | ||
161 | // Remove this valve from our list | |
162 | 0 | Valve[] results = new Valve[valves.length - 1]; |
163 | 0 | int n = 0; |
164 | 0 | for (int i = 0; i < valves.length; i++) |
165 | { | |
166 | 0 | if (i == index) |
167 | { | |
168 | 0 | continue; |
169 | } | |
170 | 0 | results[n++] = valves[i]; |
171 | } | |
172 | 0 | valves = results; |
173 | 0 | } |
174 | 0 | } |
175 | ||
176 | /** | |
177 | * @see org.apache.turbine.pipeline.Pipeline#invoke(PipelineData) | |
178 | */ | |
179 | @Override | |
180 | public void invoke(PipelineData pipelineData) | |
181 | throws TurbineException, IOException | |
182 | { | |
183 | // Initialize the per-thread state for this thread | |
184 | 13 | state.set(Integer.valueOf(0)); |
185 | ||
186 | // Invoke the first Valve in this pipeline for this request | |
187 | 13 | invokeNext(pipelineData); |
188 | 12 | } |
189 | ||
190 | /** | |
191 | * @see org.apache.turbine.pipeline.ValveContext#invokeNext(PipelineData) | |
192 | */ | |
193 | @Override | |
194 | public void invokeNext(PipelineData pipelineData) | |
195 | throws TurbineException, IOException | |
196 | { | |
197 | // Identify the current subscript for the current request thread | |
198 | 32 | Integer current = state.get(); |
199 | 32 | int subscript = current.intValue(); |
200 | ||
201 | 32 | if (subscript < valves.length) |
202 | { | |
203 | // Invoke the requested Valve for the current request | |
204 | // thread and increment its thread-local state. | |
205 | 20 | state.set(Integer.valueOf(subscript + 1)); |
206 | 20 | valves[subscript].invoke(pipelineData, this); |
207 | } | |
208 | 25 | } |
209 | } |