View Javadoc

1   /*** 
2    * 
3    * Copyright 2004 Hiram Chirino
4    * 
5    * Licensed under the Apache License, Version 2.0 (the "License"); 
6    * you may not use this file except in compliance with the License. 
7    * You may obtain a copy of the License at 
8    * 
9    * http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS, 
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
14   * See the License for the specific language governing permissions and 
15   * limitations under the License. 
16   * 
17   **/
18  package org.activeio.adapter;
19  
20  import java.io.IOException;
21  import java.io.InterruptedIOException;
22  import java.net.URI;
23  
24  import org.activeio.AcceptListener;
25  import org.activeio.AsynchChannelServer;
26  import org.activeio.Channel;
27  import org.activeio.ChannelServer;
28  import org.activeio.SynchChannelServer;
29  
30  import EDU.oswego.cs.dl.util.concurrent.LinkedQueue;
31  
32  /***
33   * Adapts a {@see org.activeio.AsynchChannelServer} so that it provides an 
34   * {@see org.activeio.SynchChannelServer} interface.  
35   * 
36   * This object buffers asynchronous accepts from the {@see org.activeio.AsynchChannelServer} 
37   * abs buffers them in a {@see EDU.oswego.cs.dl.util.concurrent.Channel} util the client accepts the 
38   * connection.
39   * 
40   * @version $Revision$
41   */
42  final public class AsynchToSynchChannelServerAdapter implements SynchChannelServer, AcceptListener {
43  
44      private final AsynchChannelServer asynchChannelServer;    
45      private final EDU.oswego.cs.dl.util.concurrent.Channel acceptBuffer;
46      
47      static public SynchChannelServer adapt(ChannelServer channel) {
48          return adapt(channel, new LinkedQueue());
49      }
50  
51      static public SynchChannelServer adapt(ChannelServer channel, EDU.oswego.cs.dl.util.concurrent.Channel upPacketChannel) {
52  
53          // It might not need adapting
54          if( channel instanceof SynchChannelServer ) {
55              return (SynchChannelServer) channel;
56          }
57  
58          // Can we just just undo the adaptor
59          if( channel.getClass() == SynchToAsynchChannelAdapter.class ) {
60              return ((SynchToAsynchChannelServerAdapter)channel).getSynchChannelServer();
61          }
62          
63          return new AsynchToSynchChannelServerAdapter((AsynchChannelServer)channel, upPacketChannel);        
64      }
65      
66      /***
67       * @deprecated {@see #adapt(ChannelServer)}
68       */
69      public AsynchToSynchChannelServerAdapter(AsynchChannelServer asynchChannelServer) {
70          this(asynchChannelServer,new LinkedQueue());
71      }
72      
73      /***
74       * @deprecated {@see #adapt(ChannelServer, EDU.oswego.cs.dl.util.concurrent.Channel)}
75       */
76      public AsynchToSynchChannelServerAdapter(AsynchChannelServer asynchChannelServer, EDU.oswego.cs.dl.util.concurrent.Channel acceptBuffer) {
77          this.asynchChannelServer = asynchChannelServer;
78          this.acceptBuffer=acceptBuffer;
79          this.asynchChannelServer.setAcceptListener(this);
80      }
81  
82      /***
83       * @see org.activeio.SynchChannelServer#accept(long)
84       */
85      public org.activeio.Channel accept(long timeout) throws IOException {
86          try {
87              
88              Object o;
89              if( timeout == NO_WAIT_TIMEOUT ) {
90                  o = acceptBuffer.poll(0);
91              } else if( timeout == WAIT_FOREVER_TIMEOUT ) {
92                  o = acceptBuffer.take();            
93              } else {
94                  o = acceptBuffer.poll(timeout);                        
95              }
96              
97              if( o == null )
98                  return null;
99              
100             if( o instanceof Channel )
101                 return (Channel)o;
102             
103             Throwable e = (Throwable)o;
104             throw (IOException)new IOException("Asynch error occured: "+e).initCause(e);
105             
106         } catch (InterruptedException e) {
107             throw new InterruptedIOException(e.getMessage());
108         }
109     }
110     /***
111      * @see org.activeio.Disposable#dispose()
112      */
113     public void dispose() {
114         asynchChannelServer.dispose();
115     }
116 
117     /***
118      * @see org.activeio.Service#start()
119      */
120     public void start() throws IOException {
121         asynchChannelServer.start();
122     }
123 
124     /***
125      * @see org.activeio.Service#stop(long)
126      */
127     public void stop(long timeout) throws IOException {
128         asynchChannelServer.stop(timeout);
129     }
130 
131     public URI getBindURI() {
132         return asynchChannelServer.getBindURI();
133     }
134 
135     public URI getConnectURI() {
136         return asynchChannelServer.getConnectURI();
137     }
138 
139     /***
140      * @see org.activeio.AcceptListener#onAccept(org.activeio.Channel)
141      */
142     public void onAccept(org.activeio.Channel channel) {
143         try {
144             acceptBuffer.put(channel);
145         } catch (InterruptedException e) {
146             Thread.currentThread().interrupt();
147         }        
148     }
149     
150     /***
151      * @see org.activeio.AcceptListener#onAcceptError(java.io.IOException)
152      */
153     public void onAcceptError(IOException error) {
154         try {
155             acceptBuffer.put(error);
156         } catch (InterruptedException e) {
157             Thread.currentThread().interrupt();
158         }        
159     }
160     
161     public AsynchChannelServer getAsynchChannelServer() {
162         return asynchChannelServer;
163     }
164     
165     public Object narrow(Class target) {
166         if( target.isAssignableFrom(getClass()) ) {
167             return this;
168         }
169         return asynchChannelServer.narrow(target);
170     }    
171     
172     public String toString() {
173         return asynchChannelServer.toString();
174     }
175 }