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.oneport;
19
20 import java.io.IOException;
21 import java.io.InputStream;
22 import java.net.MalformedURLException;
23 import java.net.URI;
24 import java.net.URISyntaxException;
25 import java.net.URL;
26
27 import javax.naming.NamingException;
28
29 import junit.framework.TestCase;
30
31 import org.activeio.AcceptListener;
32 import org.activeio.AsynchChannel;
33 import org.activeio.AsynchChannelFactory;
34 import org.activeio.AsynchChannelServer;
35 import org.activeio.Channel;
36 import org.activeio.FilterAsynchChannelServer;
37 import org.activeio.FilterSynchChannel;
38 import org.activeio.Packet;
39 import org.activeio.SynchChannel;
40 import org.activeio.adapter.AsynchToSynchChannelAdapter;
41 import org.activeio.adapter.SynchToAsynchChannelFactoryAdaptor;
42 import org.activeio.net.SocketMetadata;
43 import org.activeio.net.SocketSynchChannelFactory;
44 import org.activeio.packet.ByteArrayPacket;
45 import org.apache.commons.logging.Log;
46 import org.apache.commons.logging.LogFactory;
47
48 import EDU.oswego.cs.dl.util.concurrent.Slot;
49 import EDU.oswego.cs.dl.util.concurrent.SynchronizedInt;
50 import EDU.oswego.cs.dl.util.concurrent.ThreadFactory;
51 import EDU.oswego.cs.dl.util.concurrent.ThreadedExecutor;
52
53 /***
54 */
55 public class OnePortAsyncChannelServerTest extends TestCase {
56
57 static private Log log = LogFactory.getLog(OnePortAsyncChannelServerTest.class);
58 static public SynchronizedInt serverPacketCounter = new SynchronizedInt(0);
59
60 public OnePortAsynchChannelServer server;
61 public AsynchChannelServer httpServer;
62 public AsynchChannelServer iiopServer;
63 public SocketSynchChannelFactory channelFactory;
64 public Slot resultSlot = new Slot();
65
66 public void testIIOPAccept() throws Exception {
67 serverPacketCounter.set(0);
68 hitIIOPServer();
69 String type = (String) resultSlot.poll(1000 * 5);
70 assertEquals("IIOP", type);
71
72 assertTrue(serverPacketCounter.get()>0);
73 }
74
75 public void testHttpAccept() throws IOException, URISyntaxException, InterruptedException {
76 serverPacketCounter.set(0);
77 hitHttpServer();
78 String type = (String) resultSlot.poll(1000 * 5 * 10000);
79 assertEquals("HTTP", type);
80
81 assertTrue(serverPacketCounter.get()>0);
82 }
83
84 protected void hitHttpServer() throws IOException, MalformedURLException {
85 URI connectURI = server.getConnectURI();
86 String url = "http://" + connectURI.getHost() + ":" + connectURI.getPort() + "/index.action";
87 log.info(url);
88 InputStream is = new URL(url).openStream();
89 StringBuffer b = new StringBuffer();
90 int c;
91 while ((c = is.read()) >= 0) {
92 b.append((char) c);
93 }
94
95 log.info("HTTP response: " + b);
96 }
97
98 protected void hitIIOPServer() throws Exception {
99 SynchChannel channel = channelFactory.openSynchChannel(server.getConnectURI());
100 ((SocketMetadata)channel.narrow(SocketMetadata.class)).setTcpNoDelay(true);
101 channel.write(new ByteArrayPacket("GIOPcrapcrap".getBytes("UTF-8")));
102 channel.flush();
103 channel.dispose();
104 }
105
106 public void testUnknownAccept() throws IOException, URISyntaxException, InterruptedException {
107 SynchChannel channel = channelFactory.openSynchChannel(server.getConnectURI());
108 ((SocketMetadata)channel.narrow(SocketMetadata.class)).setTcpNoDelay(true);
109 channel
110 .write(new ByteArrayPacket("Licensed under the Apache License, Version 2.0 (the \"License\")"
111 .getBytes("UTF-8")));
112 channel.flush();
113 String type = (String) resultSlot.poll(1000 * 5);
114 assertNull(type);
115 channel.dispose();
116 }
117
118 protected void setUp() throws Exception {
119 channelFactory = new SocketSynchChannelFactory();
120 ThreadedExecutor executor = new ThreadedExecutor();
121 executor.setThreadFactory(new ThreadFactory(){
122 int count=0;
123 public Thread newThread(Runnable arg0) {
124 return new Thread(arg0, "activeio:"+(count++));
125 }});
126 AsynchChannelFactory factory = SynchToAsynchChannelFactoryAdaptor.adapt(channelFactory,executor);
127
128 AsynchChannelServer cs = factory.bindAsynchChannel(new URI("tcp://localhost:0"));
129 cs = new FilterAsynchChannelServer(cs) {
130 public void onAccept(Channel channel) {
131 SynchChannel synchChannel = AsynchToSynchChannelAdapter.adapt(channel);
132 super.onAccept(new FilterSynchChannel(synchChannel) {
133 public org.activeio.Packet read(long timeout) throws IOException {
134 Packet packet = super.read(timeout);
135 if( packet!=null && packet.hasRemaining() )
136 serverPacketCounter.increment();
137 return packet;
138 }
139 });
140 }
141 };
142
143 server = new OnePortAsynchChannelServer(cs);
144 server.start();
145
146 startHTTPServer();
147 startIIOPServer();
148
149 log.info("Running on: "+server.getConnectURI());
150 }
151
152 /***
153 * @throws IOException
154 * @throws NamingException
155 */
156 protected void startIIOPServer() throws Exception {
157 iiopServer = server.bindAsynchChannel(IIOPRecognizer.IIOP_RECOGNIZER);
158 iiopServer.setAcceptListener(new AcceptListener() {
159 public void onAccept(Channel channel) {
160 try {
161 log.info("Got a IIOP connection.");
162 resultSlot.offer("IIOP", 1);
163 channel.dispose();
164 } catch (InterruptedException e) {
165 e.printStackTrace();
166 }
167 }
168
169 public void onAcceptError(IOException error) {
170 }
171 });
172 iiopServer.start();
173 }
174
175 /***
176 * @throws IOException
177 * @throws Exception
178 */
179 protected void startHTTPServer() throws Exception {
180 httpServer = server.bindAsynchChannel(HttpRecognizer.HTTP_RECOGNIZER);
181 httpServer.setAcceptListener(new AcceptListener() {
182 public void onAccept(Channel channel) {
183 try {
184 log.info("Got a HTTP connection.");
185 resultSlot.offer("HTTP", 1);
186
187 byte data[] = ("HTTP/1.1 200 OK\r\n" + "Content-Type: text/html; charset=UTF-8\r\n" + "\r\n"
188 + "Hello World").getBytes("UTF-8");
189
190 ((SocketMetadata)channel.narrow(SocketMetadata.class)).setTcpNoDelay(true);
191 ((AsynchChannel) channel).write(new ByteArrayPacket(data));
192
193 channel.dispose();
194 } catch (Throwable e) {
195 e.printStackTrace();
196 }
197 }
198
199 public void onAcceptError(IOException error) {
200 }
201 });
202 httpServer.start();
203 }
204
205 protected void tearDown() throws Exception {
206 stopIIOPServer();
207 stopHTTPServer();
208 server.dispose();
209 }
210
211 /***
212 * @throws InterruptedException
213 *
214 */
215 protected void stopHTTPServer() throws InterruptedException {
216 httpServer.dispose();
217 }
218
219 /***
220 * @throws Exception
221 *
222 */
223 protected void stopIIOPServer() throws Exception {
224 iiopServer.dispose();
225 }
226 }