Java AcceptingChannel类代码示例

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
@Deprecated
public static void installConnectorServicesForNetworkInterfaceBinding(ServiceTarget serviceTarget,
                                                                      final ServiceName endpointName,
                                                                      final String connectorName,
                                                                      final ServiceName networkInterfaceBindingName,
                                                                      final int port,
                                                                      final OptionMap connectorPropertiesOptionMap,
                                                                      final ServiceName securityRealm,
                                                                      final ServiceName saslAuthenticationFactory,
                                                                      final ServiceName sslContext,
                                                                      final ServiceName socketBindingManager) {
    final InjectedNetworkBindingStreamServerService streamServerService = new InjectedNetworkBindingStreamServerService(connectorPropertiesOptionMap, port);

    final ServiceBuilder<AcceptingChannel<StreamConnection>> serviceBuilder = serviceTarget.addService(serverServiceName(connectorName), streamServerService)
                .addDependency(networkInterfaceBindingName, NetworkInterfaceBinding.class, streamServerService.getInterfaceBindingInjector());
    if (socketBindingManager != null) {
        serviceBuilder.addDependency(socketBindingManager, SocketBindingManager.class, streamServerService.getSocketBindingManagerInjector());
    }
    installConnectorServices(serviceBuilder, streamServerService, endpointName, securityRealm, saslAuthenticationFactory, sslContext);
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
public static void installConnectorServicesForSocketBinding(ServiceTarget serviceTarget,
                                                            final ServiceName endpointName,
                                                            final String connectorName,
                                                            final ServiceName socketBindingName,
                                                            final OptionMap connectorPropertiesOptionMap,
                                                            final ServiceName securityRealm,
                                                            final ServiceName saslAuthenticationFactory,
                                                            final ServiceName sslContext,
                                                            final ServiceName socketBindingManager) {
    final InjectedSocketBindingStreamServerService streamServerService = new InjectedSocketBindingStreamServerService(connectorPropertiesOptionMap);
    final ServiceBuilder<AcceptingChannel<StreamConnection>> serviceBuilder = serviceTarget.addService(serverServiceName(connectorName), streamServerService)
            .addDependency(socketBindingName, SocketBinding.class, streamServerService.getSocketBindingInjector())
            .addDependency(socketBindingManager, SocketBindingManager.class, streamServerService.getSocketBindingManagerInjector());

    installConnectorServices(serviceBuilder, streamServerService, endpointName, securityRealm, saslAuthenticationFactory, sslContext);
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
private static void installConnectorServices(final ServiceBuilder<AcceptingChannel<StreamConnection>> serviceBuilder,
                                             final AbstractStreamServerService service,
                                             final ServiceName endpointName,
                                             final ServiceName securityRealm,
                                             final ServiceName saslAuthenticationFactory,
                                             final ServiceName sslContext) {

    serviceBuilder.addDependency(endpointName, Endpoint.class, service.getEndpointInjector());
    if (securityRealm != null) {
        serviceBuilder.addDependency(securityRealm, SecurityRealm.class, service.getSecurityRealmInjector());
    }
    if (saslAuthenticationFactory != null) {
        serviceBuilder.addDependency(saslAuthenticationFactory, SaslAuthenticationFactory.class, service.getSaslAuthenticationFactoryInjector());
    }
    if (sslContext != null) {
        serviceBuilder.addDependency(sslContext, SSLContext.class, service.getSSLContextInjector());
    }
    serviceBuilder.install();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
private AcceptingChannel<? extends StreamConnection> createServer(int sourcePort, int targetPort)
    throws IllegalArgumentException, IOException {
    OptionMap socketOptions = OptionMap.builder()
        .set(Options.WORKER_IO_THREADS, 16)
        .set(Options.TCP_NODELAY, true)
        .set(Options.REUSE_ADDRESSES, true)
        .getMap();

    ChannelListener<AcceptingChannel<StreamConnection>> acceptListener = ChannelListeners.openListenerAdapter(
        new PortForwardOpenListener(connection, portForwardURI.getPath(), targetPort, requestId, bufferPoolSlice,
            OptionMap.EMPTY));
    AcceptingChannel<? extends StreamConnection> server =
        xnioWorker.createStreamConnectionServer(new InetSocketAddress(portForwardBindAddress, sourcePort),
            acceptListener, socketOptions);
    server.resumeAccepts();
    return server;
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
public synchronized void stop() {
    for (AcceptingChannel<? extends StreamConnection> channel : channels) {
        IoUtils.safeClose(channel);
    }
    channels = null;
    worker.shutdownNow();
    worker = null;
    xnio = null;
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
@Override
protected void close() {
    if (null == channels) {
        // not booted yet
        return;
    }
    for (AcceptingChannel<? extends StreamConnection> channel : channels) {
        IO.close(channel);
    }
    channels.clear();
    worker.shutdownNow();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
private ChannelServer(final Endpoint endpoint,
        final Registration registration,
        final AcceptingChannel<StreamConnection> streamServer) {
    this.endpoint = endpoint;
    this.registration = registration;
    this.streamServer = streamServer;
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
public static ChannelServer create(final Configuration configuration) throws IOException {
    if (configuration == null) {
        throw new IllegalArgumentException("Null configuration");
    }
    configuration.validate();

    // Hack WFCORE-3302/REM3-303 workaround
    if (firstCreate) {
        firstCreate = false;
    } else {
        try {
            // wait in case the previous socket has not closed
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }

    // TODO WFCORE-3302 -- Endpoint.getCurrent() should be ok
    final Endpoint endpoint = Endpoint.builder().setEndpointName(configuration.getEndpointName()).build();

    final NetworkServerProvider networkServerProvider = endpoint.getConnectionProviderInterface(configuration.getUriScheme(), NetworkServerProvider.class);
    final SecurityDomain.Builder domainBuilder = SecurityDomain.builder();
    final SimpleMapBackedSecurityRealm realm = new SimpleMapBackedSecurityRealm();
    domainBuilder.addRealm("default", realm).build();
    domainBuilder.setDefaultRealmName("default");
    domainBuilder.setPermissionMapper((permissionMappable, roles) -> PermissionVerifier.ALL);
    SecurityDomain testDomain = domainBuilder.build();
    SaslAuthenticationFactory saslAuthenticationFactory = SaslAuthenticationFactory.builder()
        .setSecurityDomain(testDomain)
        .setMechanismConfigurationSelector(mechanismInformation -> "ANONYMOUS".equals(mechanismInformation.getMechanismName()) ? MechanismConfiguration.EMPTY : null)
        .setFactory(new AnonymousServerFactory())
        .build();
    System.out.println(configuration.getBindAddress());
    AcceptingChannel<StreamConnection> streamServer = networkServerProvider.createServer(configuration.getBindAddress(), OptionMap.EMPTY, saslAuthenticationFactory, null);

    return new ChannelServer(endpoint, null, streamServer);
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
public int getJaxrsPort() {
    try {
        Field channelsField = server.getClass().getDeclaredField("channels");
        List<AcceptingChannel<? extends StreamConnection>> channels = InjectionUtils.readObjectFromField(server, channelsField);
        return ((InetSocketAddress)channels.get(0).getLocalAddress()).getPort();
    } catch (NoSuchFieldException e) {
        throw new JaxRsException("Failed getting listener port", e);
    }

}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
/**
 * Create a new {@link WrappingXnioSocketChannel} which was created via the given {@link AcceptingChannel} and uses
 * the given {@link StreamConnection} under the covers.
 */
public WrappingXnioSocketChannel(AcceptingChannel<StreamConnection> parent, StreamConnection channel) {
    this(new WrappingXnioServerSocketChannel(parent), channel);
    // register a EventLoop and start read
    unsafe().register(new XnioEventLoop(thread), unsafe().voidPromise());
    read();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
/**
 * Create a new instance wrapping the given {@link AcceptingChannel}
 */
@SuppressWarnings("unchecked")
public WrappingXnioServerSocketChannel(AcceptingChannel channel) {
    if (channel == null) {
        throw new NullPointerException("channel");
    }
    this.channel = channel;
    thread = channel.getIoThread();
    channel.getAcceptSetter().set(new AcceptListener());
    // register a EventLoop and start read
    unsafe().register(new XnioEventLoop(channel.getWorker().getIoThread()), unsafe().voidPromise());
    read();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
@Override
protected SocketAddress localAddress0() {
    AcceptingChannel channel = xnioChannel();
    if (channel == null) {
        return null;
    }
    return channel.getLocalAddress();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
@Override
protected void doClose() throws Exception {
    AcceptingChannel channel = xnioChannel();
    if (channel == null) {
        return;
    }
    channel.suspendAccepts();
    channel.close();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
@Override
protected void doBeginRead() throws Exception {
    AcceptingChannel channel = xnioChannel();
    if (channel == null) {
        return;
    }
    channel.resumeAccepts();
}
 

import org.xnio.channels.AcceptingChannel; //导入依赖的package包/类
@Override
public AcceptingChannel<StreamConnection> getValue() throws IllegalStateException, IllegalArgumentException {
    return streamServer;
}