How to use org.kaazing.gateway.transport.bio

MulticastTransport() {
  acceptor = new MulticastAcceptor();
  connector = new MulticastConnector();
}

  @Override
  protected SocketAddressFactory<MulticastAddress> initSocketAddressFactory() {
    return new MulticastAddressFactory();
  }
}

@Override
protected NamedPipeAcceptorImpl getAcceptor() {
  return (NamedPipeAcceptorImpl) super.getAcceptor();
}

protected final void init() {
  connector = initConnector();
  connector.setHandler(new BridgeConnectHandler() {
    @Override
    public void sessionCreated(IoSession session) throws Exception {
      LoggingFilter.addIfNeeded(logger, session, getTransportName());
      super.sessionCreated(session);
    }
  });
  socketAddressFactory = initSocketAddressFactory();
  bridgeServiceFactory = initBridgeServiceFactory();
  resourceAddressFactory = initResourceAddressFactory();
}

private ResourceAddress createResourceAddress(MulticastAddress multicastAddress, String nextProtocol) {
  String transportName = getTransportName();
  InetAddress inetAddress = multicastAddress.getGroupAddress();
  String hostAddress = inetAddress.getHostAddress();
  String addressFormat = (inetAddress instanceof Inet6Address) ? "%s://[%s]:%s" : "%s://%s:%s";
  int port = multicastAddress.getBindPort();
  String transport = format(addressFormat, transportName, hostAddress, port);
  return resourceAddressFactory.newResourceAddress(transport, nextProtocol);
}

public Handle(MulticastAddress localAddress) throws IOException {
  this.localAddress = localAddress;
  this.socket = new MulticastSocket(new InetSocketAddress(localAddress.getGroupAddress(), localAddress.getBindPort()));
  this.groupAddress = new InetSocketAddress(localAddress.getGroupAddress(), 0);
  this.device = localAddress.getDevice();
}

@Override
public void remove(MulticastSession session) {
  session.getSocket().close();
  
  getSessionRecycler().remove(session);
  getListeners().fireSessionDestroyed(session);
}

@Override
public ConnectFuture connect(ResourceAddress address, IoHandler handler, IoSessionInitializer<? extends ConnectFuture> initializer) {
  if (!started.get()) {
    synchronized (started) {
      if (!started.get()) {
        init();
        started.set(true);
      }
    }
  }
  return connectInternal(address, handler, initializer);
}

  @Override
  public void sessionCreated(IoSession session) throws Exception {
    LoggingFilter.addIfNeeded(logger, session, getTransportName());
    super.sessionCreated(session);
  }
});

@Override
public Transport newTransport(Map<String, ?> configuration) {
  return new MulticastTransport();
}

private ResourceAddress asResourceAddress(SocketAddress socketAddress) {
  return asResourceAddress(socketAddress, null);
}

private ResourceAddress asResourceAddress(SocketAddress socketAddress, String nextProtocol) {
  if (socketAddress instanceof InetSocketAddress) {
    InetSocketAddress inetSocketAddress = (InetSocketAddress) socketAddress;
    return createResourceAddress(inetSocketAddress, nextProtocol);
  }
  else if (socketAddress instanceof NamedPipeAddress) {
    NamedPipeAddress pipeAddress = (NamedPipeAddress) socketAddress;
    return createResourceAddress(pipeAddress, nextProtocol);
  }
  else if (socketAddress instanceof MulticastAddress) {
    MulticastAddress multicastAddress = (MulticastAddress) socketAddress;
    return createResourceAddress(multicastAddress, nextProtocol);
  }
  return (ResourceAddress) socketAddress;
}

public MulticastAcceptorImpl(IoSessionConfigEx sessionConfig, Executor executor) {
  super(sessionConfig, executor);
  
  boundHandles = new ConcurrentHashMap<>();
  processor = new MulticastProcessor();
}

@Override
protected IoFuture dispose0() throws Exception {
  // leave all the multicast groups
  for (Handle handle : boundHandles.values()) {
    handle.leaveGroup();
  }
  
  return null;
}

@Override
public void remove(MulticastSession session) {
  getListeners().fireSessionDestroyed(session);
}

private void setLocalAddressFromSocketAddress(final IoSession session,
                       final String transportName, String nextProtocol) {
  SocketAddress socketAddress = session.getLocalAddress();
  if (socketAddress instanceof InetSocketAddress) {
    InetSocketAddress inetSocketAddress = (InetSocketAddress) socketAddress;
    ResourceAddress resourceAddress = newResourceAddress(inetSocketAddress, transportName, nextProtocol);
    LOCAL_ADDRESS.set(session, resourceAddress);
  }
  else if (socketAddress instanceof NamedPipeAddress) {
    NamedPipeAddress namedPipeAddress = (NamedPipeAddress) socketAddress;
    ResourceAddress resourceAddress = newResourceAddress(namedPipeAddress, transportName, nextProtocol);
    LOCAL_ADDRESS.set(session, resourceAddress);
  }
}

@Override
protected BindFuture bindAsyncInternal(SocketAddress localAddress) {
  List<? extends SocketAddress> localAddresses = Collections.singletonList(localAddress);
  try {
    bindInternal(localAddresses);
    return DefaultBindFuture.succeededFuture();
  } catch (Exception e) {
    DefaultBindFuture bindFuture = new DefaultBindFuture();
    bindFuture.setException(e);
    return bindFuture;
  }
}

@Override
protected UnbindFuture unbindAsyncInternal(SocketAddress localAddress) {
  List<? extends SocketAddress> localAddresses = Collections.singletonList(localAddress);
  try {
    unbind0(localAddresses);
    return DefaultUnbindFuture.succeededFuture();
  } catch (Exception e) {
    DefaultUnbindFuture unbindFuture = new DefaultUnbindFuture();
    unbindFuture.setException(e);
    return unbindFuture;
  }
}

@Override
protected SocketAddressFactory<MulticastAddress> initSocketAddressFactory() {
  return new MulticastAddressFactory();
}

  @Override
  public void initializeSession(IoSession session, F future) {
    REMOTE_ADDRESS.set(session, remoteAddress);
    setLocalAddressFromSocketAddress(session, getTransportName(), nextProtocol);
    if (initializer != null) {
      initializer.initializeSession(session, future);
    }
  }
});