SynchChannelServerToServerSocketAdapter xref

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  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 }