%line | %branch | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
org.apache.jcs.auxiliary.lateral.socket.tcp.LateralTCPService |
|
|
1 | package org.apache.jcs.auxiliary.lateral.socket.tcp; |
|
2 | ||
3 | /* |
|
4 | * Licensed to the Apache Software Foundation (ASF) under one |
|
5 | * or more contributor license agreements. See the NOTICE file |
|
6 | * distributed with this work for additional information |
|
7 | * regarding copyright ownership. The ASF licenses this file |
|
8 | * to you under the Apache License, Version 2.0 (the |
|
9 | * "License"); you may not use this file except in compliance |
|
10 | * with the License. You may obtain a copy of the License at |
|
11 | * |
|
12 | * http://www.apache.org/licenses/LICENSE-2.0 |
|
13 | * |
|
14 | * Unless required by applicable law or agreed to in writing, |
|
15 | * software distributed under the License is distributed on an |
|
16 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
|
17 | * KIND, either express or implied. See the License for the |
|
18 | * specific language governing permissions and limitations |
|
19 | * under the License. |
|
20 | */ |
|
21 | ||
22 | import java.io.BufferedReader; |
|
23 | import java.io.IOException; |
|
24 | import java.io.InputStreamReader; |
|
25 | import java.io.Serializable; |
|
26 | import java.util.Set; |
|
27 | ||
28 | import org.apache.commons.logging.Log; |
|
29 | import org.apache.commons.logging.LogFactory; |
|
30 | import org.apache.jcs.auxiliary.lateral.LateralCacheInfo; |
|
31 | import org.apache.jcs.auxiliary.lateral.LateralElementDescriptor; |
|
32 | import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheObserver; |
|
33 | import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService; |
|
34 | import org.apache.jcs.auxiliary.lateral.socket.tcp.behavior.ITCPLateralCacheAttributes; |
|
35 | import org.apache.jcs.engine.CacheElement; |
|
36 | import org.apache.jcs.engine.behavior.ICacheElement; |
|
37 | import org.apache.jcs.engine.behavior.ICacheListener; |
|
38 | ||
39 | /** |
|
40 | * A lateral cache service implementation. Does not implement getGroupKey |
|
41 | * <p> |
|
42 | * @version $Id: LateralTCPService.java 536904 2007-05-10 16:03:42Z tv $ |
|
43 | */ |
|
44 | public class LateralTCPService |
|
45 | implements ILateralCacheService, ILateralCacheObserver |
|
46 | { |
|
47 | 28 | private final static Log log = LogFactory.getLog( LateralTCPService.class ); |
48 | ||
49 | private ITCPLateralCacheAttributes tcpLateralCacheAttributes; |
|
50 | ||
51 | private LateralTCPSender sender; |
|
52 | ||
53 | /** |
|
54 | * use the vmid by default |
|
55 | */ |
|
56 | 34 | private long listenerId = LateralCacheInfo.listenerId; |
57 | ||
58 | /** |
|
59 | * Constructor for the LateralTCPService object |
|
60 | * <p> |
|
61 | * @param lca ITCPLateralCacheAttributes |
|
62 | * @exception IOException |
|
63 | */ |
|
64 | public LateralTCPService( ITCPLateralCacheAttributes lca ) |
|
65 | throws IOException |
|
66 | 34 | { |
67 | 34 | this.setTcpLateralCacheAttributes( lca ); |
68 | try |
|
69 | { |
|
70 | 34 | log.debug( "creating sender, attributes = " + getTcpLateralCacheAttributes() ); |
71 | ||
72 | 34 | sender = new LateralTCPSender( lca ); |
73 | ||
74 | 20 | if ( log.isInfoEnabled() ) |
75 | { |
|
76 | 20 | log.debug( "Created sender to [" + lca.getTcpServer() + "]" ); |
77 | } |
|
78 | } |
|
79 | 14 | catch ( IOException e ) |
80 | { |
|
81 | // log.error( "Could not create sender", e ); |
|
82 | // This gets thrown over and over in recovery mode. |
|
83 | // The stack trace isn't useful here. |
|
84 | 14 | log.error( "Could not create sender to [" + lca.getTcpServer() + "] -- " + e.getMessage() ); |
85 | ||
86 | 14 | throw e; |
87 | 20 | } |
88 | 20 | } |
89 | ||
90 | /** |
|
91 | * @param item |
|
92 | * @throws IOException |
|
93 | */ |
|
94 | public void update( ICacheElement item ) |
|
95 | throws IOException |
|
96 | { |
|
97 | 1419 | update( item, getListenerId() ); |
98 | 1419 | } |
99 | ||
100 | /** |
|
101 | * If put is allowed, we will issue a put. If issue put on remove is configured, we will issue a |
|
102 | * remove. Either way, we create a lateral element descriptor, which is essentially a JCS TCP |
|
103 | * packet. It describes what operation the receiver should take when it gets the packet. |
|
104 | * <p> |
|
105 | * @see org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService#update(org.apache.jcs.engine.behavior.ICacheElement, |
|
106 | * long) |
|
107 | */ |
|
108 | public void update( ICacheElement item, long requesterId ) |
|
109 | throws IOException |
|
110 | { |
|
111 | // if we don't allow put, see if we should remove on put |
|
112 | 1419 | if ( !this.getTcpLateralCacheAttributes().isAllowPut() ) |
113 | { |
|
114 | // if we can't remove on put, and we can't put then return |
|
115 | 1412 | if ( !this.getTcpLateralCacheAttributes().isIssueRemoveOnPut() ) |
116 | { |
|
117 | 0 | return; |
118 | } |
|
119 | } |
|
120 | ||
121 | // if we shouldn't remove on put, then put |
|
122 | 1419 | if ( !this.getTcpLateralCacheAttributes().isIssueRemoveOnPut() ) |
123 | { |
|
124 | 7 | LateralElementDescriptor led = new LateralElementDescriptor( item ); |
125 | 7 | led.requesterId = requesterId; |
126 | 7 | led.command = LateralElementDescriptor.UPDATE; |
127 | 7 | sender.send( led ); |
128 | 7 | } |
129 | // else issue a remove with the hashcode for remove check on |
|
130 | // on the other end, this will be a server config option |
|
131 | else |
|
132 | { |
|
133 | 1412 | if ( log.isDebugEnabled() ) |
134 | { |
|
135 | 0 | log.debug( "Issuing a remove for a put" ); |
136 | } |
|
137 | // set the value to null so we don't send the item |
|
138 | 1412 | CacheElement ce = new CacheElement( item.getCacheName(), item.getKey(), null ); |
139 | 1412 | LateralElementDescriptor led = new LateralElementDescriptor( ce ); |
140 | 1412 | led.requesterId = requesterId; |
141 | 1412 | led.command = LateralElementDescriptor.REMOVE; |
142 | 1412 | led.valHashCode = item.getVal().hashCode(); |
143 | 1412 | sender.send( led ); |
144 | } |
|
145 | 1419 | } |
146 | ||
147 | /** |
|
148 | * Uses the default listener id and calls the next remove method. |
|
149 | * <p> |
|
150 | * @see org.apache.jcs.engine.behavior.ICacheService#remove(java.lang.String, |
|
151 | * java.io.Serializable) |
|
152 | */ |
|
153 | public void remove( String cacheName, Serializable key ) |
|
154 | throws IOException |
|
155 | { |
|
156 | 0 | remove( cacheName, key, getListenerId() ); |
157 | 0 | } |
158 | ||
159 | /** |
|
160 | * Wraps the key in a LateralElementDescriptor. |
|
161 | * <p> |
|
162 | * @see org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService#remove(java.lang.String, |
|
163 | * java.io.Serializable, long) |
|
164 | */ |
|
165 | public void remove( String cacheName, Serializable key, long requesterId ) |
|
166 | throws IOException |
|
167 | { |
|
168 | 0 | CacheElement ce = new CacheElement( cacheName, key, null ); |
169 | 0 | LateralElementDescriptor led = new LateralElementDescriptor( ce ); |
170 | 0 | led.requesterId = requesterId; |
171 | 0 | led.command = LateralElementDescriptor.REMOVE; |
172 | 0 | sender.send( led ); |
173 | 0 | } |
174 | ||
175 | /* |
|
176 | * (non-Javadoc) |
|
177 | * @see org.apache.jcs.engine.behavior.ICacheService#release() |
|
178 | */ |
|
179 | public void release() |
|
180 | throws IOException |
|
181 | { |
|
182 | // nothing needs to be done |
|
183 | 0 | } |
184 | ||
185 | /** |
|
186 | * Will close the connection. |
|
187 | * <p> |
|
188 | * @param cacheName |
|
189 | * @throws IOException |
|
190 | */ |
|
191 | public void dispose( String cacheName ) |
|
192 | throws IOException |
|
193 | { |
|
194 | 0 | sender.dispose( cacheName ); |
195 | 0 | } |
196 | ||
197 | /** |
|
198 | * The service does not get via this method, so this return null. |
|
199 | * <p> |
|
200 | * @param key |
|
201 | * @return always null. |
|
202 | * @throws IOException |
|
203 | */ |
|
204 | public Serializable get( String key ) |
|
205 | throws IOException |
|
206 | { |
|
207 | 0 | if ( log.isDebugEnabled() ) |
208 | { |
|
209 | 0 | log.debug( "balking at get for key [" + key + "]" ); |
210 | } |
|
211 | // p( "junk get" ); |
|
212 | // return get( cattr.cacheName, key, true ); |
|
213 | 0 | return null; |
214 | // nothing needs to be done |
|
215 | } |
|
216 | ||
217 | /* |
|
218 | * (non-Javadoc) |
|
219 | * @see org.apache.jcs.engine.behavior.ICacheService#get(java.lang.String, java.io.Serializable) |
|
220 | */ |
|
221 | public ICacheElement get( String cacheName, Serializable key ) |
|
222 | throws IOException |
|
223 | { |
|
224 | // if get is not allowed return |
|
225 | 0 | if ( this.getTcpLateralCacheAttributes().isAllowGet() ) |
226 | { |
|
227 | 0 | CacheElement ce = new CacheElement( cacheName, key, null ); |
228 | 0 | LateralElementDescriptor led = new LateralElementDescriptor( ce ); |
229 | // led.requesterId = requesterId; // later |
|
230 | 0 | led.command = LateralElementDescriptor.GET; |
231 | 0 | return sender.sendAndReceive( led ); |
232 | } |
|
233 | else |
|
234 | { |
|
235 | // nothing needs to be done |
|
236 | 0 | return null; |
237 | } |
|
238 | } |
|
239 | ||
240 | /** |
|
241 | * Gets the set of keys of objects currently in the group throws UnsupportedOperationException |
|
242 | * <p> |
|
243 | * @param cacheName |
|
244 | * @param group |
|
245 | * @return Set |
|
246 | */ |
|
247 | public Set getGroupKeys( String cacheName, String group ) |
|
248 | { |
|
249 | if ( true ) |
|
250 | { |
|
251 | 0 | throw new UnsupportedOperationException( "Groups not implemented." ); |
252 | } |
|
253 | return null; |
|
254 | } |
|
255 | ||
256 | /* |
|
257 | * (non-Javadoc) |
|
258 | * @see org.apache.jcs.engine.behavior.ICacheService#removeAll(java.lang.String) |
|
259 | */ |
|
260 | public void removeAll( String cacheName ) |
|
261 | throws IOException |
|
262 | { |
|
263 | 0 | removeAll( cacheName, getListenerId() ); |
264 | 0 | } |
265 | ||
266 | /* |
|
267 | * (non-Javadoc) |
|
268 | * @see org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService#removeAll(java.lang.String, |
|
269 | * long) |
|
270 | */ |
|
271 | public void removeAll( String cacheName, long requesterId ) |
|
272 | throws IOException |
|
273 | { |
|
274 | 0 | CacheElement ce = new CacheElement( cacheName, "ALL", null ); |
275 | 0 | LateralElementDescriptor led = new LateralElementDescriptor( ce ); |
276 | 0 | led.requesterId = requesterId; |
277 | 0 | led.command = LateralElementDescriptor.REMOVEALL; |
278 | 0 | sender.send( led ); |
279 | 0 | } |
280 | ||
281 | /** |
|
282 | * @param args |
|
283 | */ |
|
284 | public static void main( String args[] ) |
|
285 | { |
|
286 | try |
|
287 | { |
|
288 | 0 | LateralTCPSender sender = new LateralTCPSender( class="keyword">new TCPLateralCacheAttributes() ); |
289 | ||
290 | // process user input till done |
|
291 | 0 | boolean notDone = true; |
292 | 0 | String message = null; |
293 | // wait to dispose |
|
294 | 0 | BufferedReader br = new BufferedReader( class="keyword">new InputStreamReader( System.in ) ); |
295 | ||
296 | 0 | while ( notDone ) |
297 | { |
|
298 | 0 | System.out.println( "enter mesage:" ); |
299 | 0 | message = br.readLine(); |
300 | 0 | CacheElement ce = new CacheElement( "test", "test", message ); |
301 | 0 | LateralElementDescriptor led = new LateralElementDescriptor( ce ); |
302 | 0 | sender.send( led ); |
303 | 0 | } |
304 | } |
|
305 | 0 | catch ( Exception e ) |
306 | { |
|
307 | 0 | System.out.println( e.toString() ); |
308 | 0 | } |
309 | 0 | } |
310 | ||
311 | // ILateralCacheObserver methods, do nothing here since |
|
312 | // the connection is not registered, the udp service is |
|
313 | // is not registered. |
|
314 | ||
315 | /* |
|
316 | * (non-Javadoc) |
|
317 | * @see org.apache.jcs.engine.behavior.ICacheObserver#addCacheListener(java.lang.String, |
|
318 | * org.apache.jcs.engine.behavior.ICacheListener) |
|
319 | */ |
|
320 | public void addCacheListener( String cacheName, ICacheListener obj ) |
|
321 | throws IOException |
|
322 | { |
|
323 | // Empty |
|
324 | 0 | } |
325 | ||
326 | /* |
|
327 | * (non-Javadoc) |
|
328 | * @see org.apache.jcs.engine.behavior.ICacheObserver#addCacheListener(org.apache.jcs.engine.behavior.ICacheListener) |
|
329 | */ |
|
330 | public void addCacheListener( ICacheListener obj ) |
|
331 | throws IOException |
|
332 | { |
|
333 | // Empty |
|
334 | 0 | } |
335 | ||
336 | /* |
|
337 | * (non-Javadoc) |
|
338 | * @see org.apache.jcs.engine.behavior.ICacheObserver#removeCacheListener(java.lang.String, |
|
339 | * org.apache.jcs.engine.behavior.ICacheListener) |
|
340 | */ |
|
341 | public void removeCacheListener( String cacheName, ICacheListener obj ) |
|
342 | throws IOException |
|
343 | { |
|
344 | // Empty |
|
345 | 0 | } |
346 | ||
347 | /* |
|
348 | * (non-Javadoc) |
|
349 | * @see org.apache.jcs.engine.behavior.ICacheObserver#removeCacheListener(org.apache.jcs.engine.behavior.ICacheListener) |
|
350 | */ |
|
351 | public void removeCacheListener( ICacheListener obj ) |
|
352 | throws IOException |
|
353 | { |
|
354 | // Empty |
|
355 | 0 | } |
356 | ||
357 | /** |
|
358 | * @param listernId The listernId to set. |
|
359 | */ |
|
360 | protected void setListenerId( long listernId ) |
|
361 | { |
|
362 | 20 | this.listenerId = listernId; |
363 | 20 | } |
364 | ||
365 | /** |
|
366 | * @return Returns the listernId. |
|
367 | */ |
|
368 | protected long getListenerId() |
|
369 | { |
|
370 | 1419 | return listenerId; |
371 | } |
|
372 | ||
373 | /** |
|
374 | * @param tcpLateralCacheAttributes The tcpLateralCacheAttributes to set. |
|
375 | */ |
|
376 | public void setTcpLateralCacheAttributes( ITCPLateralCacheAttributes tcpLateralCacheAttributes ) |
|
377 | { |
|
378 | 34 | this.tcpLateralCacheAttributes = tcpLateralCacheAttributes; |
379 | 34 | } |
380 | ||
381 | /** |
|
382 | * @return Returns the tcpLateralCacheAttributes. |
|
383 | */ |
|
384 | public ITCPLateralCacheAttributes getTcpLateralCacheAttributes() |
|
385 | { |
|
386 | 4284 | return tcpLateralCacheAttributes; |
387 | } |
|
388 | ||
389 | } |
This report is generated by jcoverage, Maven and Maven JCoverage Plugin. |