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 package org.activeio.adapter;
18
19 import java.io.IOException;
20 import java.io.InterruptedIOException;
21 import java.net.InetAddress;
22 import java.net.InetSocketAddress;
23 import java.net.ServerSocket;
24 import java.net.Socket;
25 import java.net.SocketAddress;
26 import java.net.SocketException;
27 import java.net.URI;
28 import java.nio.channels.ServerSocketChannel;
29
30 import org.activeio.Channel;
31 import org.activeio.SynchChannel;
32 import org.activeio.SynchChannelServer;
33
34 /***
35 */
36 public class SynchChannelServerToServerSocketAdapter extends ServerSocket {
37
38 private final SynchChannelServer channelServer;
39 private long timeout = Channel.WAIT_FOREVER_TIMEOUT;
40 boolean closed;
41 private InetAddress inetAddress;
42 private int localPort;
43 private SocketAddress localSocketAddress;
44 private int receiveBufferSize;
45 private boolean reuseAddress;
46
47 /***
48 * @throws IOException
49 */
50 public SynchChannelServerToServerSocketAdapter(SynchChannelServer channelServer) throws IOException {
51 this.channelServer = channelServer;
52 URI connectURI = channelServer.getConnectURI();
53 localPort = connectURI.getPort();
54 inetAddress = InetAddress.getByName(connectURI.getHost());
55 localSocketAddress = new InetSocketAddress(inetAddress, localPort);
56 }
57
58 public synchronized void setSoTimeout(int timeout) throws SocketException {
59 if( timeout <= 0 )
60 this.timeout = Channel.WAIT_FOREVER_TIMEOUT;
61 else
62 this.timeout = timeout;
63 }
64
65 public synchronized int getSoTimeout() throws IOException {
66 if( timeout == Channel.WAIT_FOREVER_TIMEOUT )
67 return 0;
68 return (int) timeout;
69 }
70
71 public Socket accept() throws IOException {
72 Channel channel = channelServer.accept(timeout);
73 if( channel==null )
74 throw new InterruptedIOException();
75
76 SynchChannel synchChannel = AsynchToSynchChannelAdapter.adapt(channel);
77 synchChannel.start();
78 return new SynchChannelToSocketAdapter(synchChannel);
79
80 }
81
82 public void bind(SocketAddress endpoint, int backlog) throws IOException {
83 if (isClosed())
84 throw new SocketException("Socket is closed");
85 throw new SocketException("Already bound");
86 }
87
88 public void bind(SocketAddress endpoint) throws IOException {
89 if (isClosed())
90 throw new SocketException("Socket is closed");
91 throw new SocketException("Already bound");
92 }
93
94 public void close() throws IOException {
95 if (!isClosed()) {
96 channelServer.dispose();
97 }
98 }
99
100 public ServerSocketChannel getChannel() {
101 return null;
102 }
103
104 public InetAddress getInetAddress() {
105 return inetAddress;
106 }
107 public int getLocalPort() {
108 return localPort;
109 }
110 public SocketAddress getLocalSocketAddress() {
111 return localSocketAddress;
112 }
113 public synchronized int getReceiveBufferSize() throws SocketException {
114 return receiveBufferSize;
115 }
116
117 public boolean getReuseAddress() throws SocketException {
118 return reuseAddress;
119 }
120
121 public boolean isBound() {
122 return true;
123 }
124
125 public boolean isClosed() {
126 return closed;
127 }
128
129 public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
130 }
131
132 public synchronized void setReceiveBufferSize(int size) throws SocketException {
133 this.receiveBufferSize = size;
134 }
135
136 public void setReuseAddress(boolean on) throws SocketException {
137 reuseAddress = on;
138 }
139 }