/** Stop the Server */ public void stop() { try { handler.destroy(); final ChannelGroupFuture future = ALL_CHANNELS.close(); future.awaitUninterruptibly(); bootstrap.getFactory().releaseExternalResources(); ALL_CHANNELS.clear(); } finally { started.set(false); } }
public static void closeChannels(ChannelGroup allChannels) { if (allChannels.size() > 0) { // TODO : allow an option here to control if we need to drain connections and wait instead of // killing them all try { log.info("Closing %s open client connections", allChannels.size()); if (!allChannels.close().await(5, TimeUnit.SECONDS)) { log.warn("Failed to close all open client connections"); } } catch (InterruptedException e) { log.warn("Interrupted while closing client connections"); Thread.currentThread().interrupt(); } } }
/** close all channels, and release resources */ public synchronized void close() { if (allChannels != null) { allChannels.close().awaitUninterruptibly(); factory.releaseExternalResources(); allChannels = null; } }
public void stop() { log.info("Shutting down proxy"); if (stopped.get()) { log.info("Already stopped"); return; } stopped.set(true); log.info("Closing all channels..."); // See http://static.netty.io/3.5/guide/#start.12 final ChannelGroupFuture future = allChannels.close(); future.awaitUninterruptibly(10 * 1000); if (!future.isCompleteSuccess()) { final Iterator<ChannelFuture> iter = future.iterator(); while (iter.hasNext()) { final ChannelFuture cf = iter.next(); if (!cf.isSuccess()) { log.warn("Cause of failure for {} is {}", cf.getChannel(), cf.getCause()); } } } log.info("Stopping timer"); timer.stop(); serverChannelFactory.releaseExternalResources(); clientChannelFactory.releaseExternalResources(); log.info("Done shutting down proxy"); }
private void actualClose(final Context closeContext, final Handler<Void> done) { if (id != null) { vertx.sharedNetServers().remove(id); } for (DefaultNetSocket sock : socketMap.values()) { sock.internalClose(); } // We need to reset it since sock.internalClose() above can call into the close handlers of // sockets on the same thread // which can cause context id for the thread to change! Context.setContext(closeContext); ChannelGroupFuture fut = serverChannelGroup.close(); if (done != null) { fut.addListener( new ChannelGroupFutureListener() { public void operationComplete(ChannelGroupFuture channelGroupFuture) throws Exception { executeCloseDone(closeContext, done); } }); } }
/** Shuts the AirReceiver down gracefully */ public static void onShutdown() { /* Close channels */ final ChannelGroupFuture allChannelsClosed = s_allChannels.close(); /* Stop all mDNS responders */ synchronized (s_jmDNSInstances) { for (final JmDNS jmDNS : s_jmDNSInstances) { try { jmDNS.unregisterAllServices(); s_logger.info("Unregistered all services on " + jmDNS.getInterface()); } catch (final IOException e) { s_logger.info("Failed to unregister some services"); } } } /* Wait for all channels to finish closing */ allChannelsClosed.awaitUninterruptibly(); /* Stop the ExecutorService */ ExecutorService.shutdown(); /* Release the OrderedMemoryAwareThreadPoolExecutor */ ChannelExecutionHandler.releaseExternalResources(); }
/** Stops this server. */ public void shutdown() { // This is so we don't run this twice (/stop and actual shutdown) if (isShuttingDown) return; isShuttingDown = true; logger.info("The server is shutting down..."); monitor.interrupt(); // Stop scheduler and disable plugins scheduler.stop(); pluginManager.clearPlugins(); // Kick (and save) all players for (Player player : getOnlinePlayers()) { player.kickPlayer("Server shutting down."); } // Save worlds for (World world : getWorlds()) { unloadWorld(world, true); } storeQueue.end(); // Gracefully stop Netty group.close(); bootstrap.getFactory().releaseExternalResources(); // And finally kill the console consoleManager.stop(); }
/** Start listening sockets */ @LogMessageDoc( level = "INFO", message = "Listening for internal floodlight RPC on {port}", explanation = "The internal RPC service is ready for connections") protected void startServer(ChannelPipelineFactory pipelineFactory) { final ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(bossExecutor, workerExecutor)); bootstrap.setOption("reuseAddr", true); bootstrap.setOption("child.keepAlive", true); bootstrap.setOption("child.tcpNoDelay", true); bootstrap.setOption("child.sendBufferSize", SEND_BUFFER_SIZE); bootstrap.setOption("child.receiveBufferSize", SEND_BUFFER_SIZE); bootstrap.setPipelineFactory(pipelineFactory); serverBootstrap = bootstrap; int port = syncManager.getClusterConfig().getNode().getPort(); InetSocketAddress sa; String listenAddress = syncManager.getClusterConfig().getListenAddress(); if (listenAddress != null) sa = new InetSocketAddress(listenAddress, port); else sa = new InetSocketAddress(port); cg.add(bootstrap.bind(sa)); logger.info("Listening for internal floodlight RPC on {}", sa); }
/** Stop the RPC service */ @LogMessageDocs({ @LogMessageDoc( level = "WARN", message = "Failed to cleanly shut down RPC server", explanation = "Could not close all open sockets cleanly"), @LogMessageDoc( level = "WARN", message = "Interrupted while shutting down RPC server", explanation = "Could not close all open sockets cleanly") }) public void shutdown() { shutDown = true; try { if (!cg.close().await(5, TimeUnit.SECONDS)) { logger.warn("Failed to cleanly shut down RPC server"); return; } if (clientBootstrap != null) clientBootstrap.releaseExternalResources(); clientBootstrap = null; if (serverBootstrap != null) serverBootstrap.releaseExternalResources(); serverBootstrap = null; if (pipelineFactory != null) pipelineFactory.releaseExternalResources(); pipelineFactory = null; if (bossExecutor != null) bossExecutor.shutdown(); bossExecutor = null; if (workerExecutor != null) workerExecutor.shutdown(); workerExecutor = null; } catch (InterruptedException e) { logger.warn("Interrupted while shutting down RPC server"); } logger.debug("Internal floodlight RPC shut down"); }
/** Stop the network manager, closing all connections and cleaning up all resources. */ public void stop() { started.set(false); logger.info("Network manager stopping!"); ChannelGroupFuture future = allChannels.close(); future.awaitUninterruptibly(); channelFactory.releaseExternalResources(); }
public void stop() { log.info("Shutting down proxy"); final ChannelGroupFuture future = allChannels.close(); future.awaitUninterruptibly(6 * 1000); serverBootstrap.releaseExternalResources(); log.info("Done shutting down proxy"); }
@Override public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { // as seen in http://www.jboss.org/netty/community.html#nabble-td2423020 super.channelOpen(ctx, e); if (group != null) { group.add(ctx.getChannel()); } }
/** Start the server */ public void start() { final Channel serverChannel = bootstrap.bind(localSocket); ALL_CHANNELS.add(serverChannel); started.set(true); if (bootstrapFlashPolicy != null) { bootstrapFlashPolicy.bind(localPolicySocket); } }
@Override public void dispose() { try { openChannels.close().awaitUninterruptibly(); } finally { channelFactory.releaseExternalResources(); } LOG.info("web server stopped"); }
public void start(final boolean localOnly, final boolean anyAddress) { log.info("Starting proxy on port: " + this.port); this.stopped.set(false); final HttpServerPipelineFactory factory = new HttpServerPipelineFactory( authenticationManager, this.allChannels, this.chainProxyManager, this.ksm, new DefaultRelayPipelineFactoryFactory( chainProxyManager, this.responseFilters, this.requestFilter, this.allChannels, timer), timer, this.clientChannelFactory, this.cacheManager); serverBootstrap.setPipelineFactory(factory); // Binding only to localhost can significantly improve the security of // the proxy. InetSocketAddress isa; if (localOnly) { isa = new InetSocketAddress("127.0.0.1", port); } else if (anyAddress) { isa = new InetSocketAddress(port); } else { try { isa = new InetSocketAddress(NetworkUtils.getLocalHost(), port); } catch (final UnknownHostException e) { log.error("Could not get local host?", e); isa = new InetSocketAddress(port); } } final Channel channel = serverBootstrap.bind(isa); allChannels.add(channel); Runtime.getRuntime() .addShutdownHook( new Thread( new Runnable() { public void run() { stop(); } })); /* final ServerBootstrap sslBootstrap = new ServerBootstrap( new NioServerSocketChannelFactory( newServerThreadPool(), newServerThreadPool())); sslBootstrap.setPipelineFactory(new HttpsServerPipelineFactory()); sslBootstrap.bind(new InetSocketAddress("127.0.0.1", 8443)); */ }
/** * Shutdown this client and close all open connections. The client should be discarded after * calling shutdown. */ public void shutdown() { for (Channel c : channels) { ChannelPipeline pipeline = c.getPipeline(); RedisAsyncConnection<?, ?> connection = pipeline.get(RedisAsyncConnection.class); connection.close(); } ChannelGroupFuture future = channels.close(); future.awaitUninterruptibly(); bootstrap.releaseExternalResources(); }
@Override public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { super.channelClosed(ctx, e); if (!ctx.getChannel().isOpen()) { tryToFinishOffChannel(ctx.getChannel()); } channelGroup.remove(e.getChannel()); }
@Override public void sendLoadMetrics(Map<Integer, Double> taskToLoad) { try { MessageBatch mb = new MessageBatch(1); mb.add(new TaskMessage(-1, _ser.serialize(Arrays.asList((Object) taskToLoad)))); allChannels.write(mb); } catch (IOException e) { throw new RuntimeException(e); } }
public void stop() { try { myScheduler.shutdown(); myBuildsExecutor.shutdown(); final ChannelGroupFuture closeFuture = myAllOpenChannels.close(); closeFuture.awaitUninterruptibly(); } finally { myChannelFactory.releaseExternalResources(); } }
public void start(int listenPort) { final ServerBootstrap bootstrap = new ServerBootstrap(myChannelFactory); bootstrap.setPipelineFactory(myPipelineFactory); bootstrap.setOption("child.tcpNoDelay", true); bootstrap.setOption("child.keepAlive", true); final Channel serverChannel = bootstrap.bind(new InetSocketAddress(listenPort)); myAllOpenChannels.add(serverChannel); startActivityMonitor(); }
public void close() throws IOException { ChannelGroupFuture f = group.close().awaitUninterruptibly(); if (!f.isCompleteSuccess()) { for (ChannelFuture future : f) { if (!future.isSuccess()) { throw new IOException(future.getCause()); } } } bootstrap.releaseExternalResources(); }
/** Start the network manager. */ public void start() throws Exception { if (!started.compareAndSet(false, true)) { throw new IllegalStateException("You already started the server!"); } logger.info("Network manager starting!"); bootstrap = serverBootstrapProvider.get(); channelFactory = channelFactoryProvider.get(); allChannels.add(bootstrap.bind(serverAddress)); }
// IDEA-91436 idea <121 binds to 127.0.0.1, but >=121 must be available not only from localhost // but if we bind only to any local port (0.0.0.0), instance of idea <121 can bind to our ports // and any request to us will be intercepted // so, we bind to 127.0.0.1 and 0.0.0.0 private int bind(int firstPort, int portsCount, boolean tryAnyPort, ServerBootstrap bootstrap) { InetAddress localAddress; try { localAddress = InetAddress.getByName("127.0.0.1"); } catch (UnknownHostException e) { LOG.error(e); return -1; } for (int i = 0; i < portsCount; i++) { int port = firstPort + i; try { openChannels.add(bootstrap.bind(new InetSocketAddress(localAddress, port))); return port; } catch (ChannelException e) { if (!openChannels.isEmpty()) { openChannels.close(); openChannels.clear(); } if (portsCount == 1) { throw e; } else if (!tryAnyPort && i == (portsCount - 1)) { LOG.error(e); } } } if (tryAnyPort) { LOG.info("We cannot bind to our default range, so, try to bind to any free port"); try { Channel channel = bootstrap.bind(new InetSocketAddress(localAddress, 0)); openChannels.add(channel); return ((InetSocketAddress) channel.getLocalAddress()).getPort(); } catch (ChannelException e) { LOG.error(e); } } return -1; }
@SuppressWarnings("rawtypes") Server(Map storm_conf, int port) { this.storm_conf = storm_conf; this.port = port; _ser = new KryoValuesSerializer(storm_conf); // Configure the server. int buffer_size = Utils.getInt(storm_conf.get(Config.STORM_MESSAGING_NETTY_BUFFER_SIZE)); int backlog = Utils.getInt(storm_conf.get(Config.STORM_MESSAGING_NETTY_SOCKET_BACKLOG), 500); int maxWorkers = Utils.getInt(storm_conf.get(Config.STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS)); ThreadFactory bossFactory = new NettyRenameThreadFactory(netty_name() + "-boss"); ThreadFactory workerFactory = new NettyRenameThreadFactory(netty_name() + "-worker"); if (maxWorkers > 0) { factory = new NioServerSocketChannelFactory( Executors.newCachedThreadPool(bossFactory), Executors.newCachedThreadPool(workerFactory), maxWorkers); } else { factory = new NioServerSocketChannelFactory( Executors.newCachedThreadPool(bossFactory), Executors.newCachedThreadPool(workerFactory)); } LOG.info( "Create Netty Server " + netty_name() + ", buffer_size: " + buffer_size + ", maxWorkers: " + maxWorkers); bootstrap = new ServerBootstrap(factory); bootstrap.setOption("child.tcpNoDelay", true); bootstrap.setOption("child.receiveBufferSize", buffer_size); bootstrap.setOption("child.keepAlive", true); bootstrap.setOption("backlog", backlog); // Set up the pipeline factory. bootstrap.setPipelineFactory(new StormServerPipelineFactory(this)); // Bind and start to accept incoming connections. Channel channel = bootstrap.bind(new InetSocketAddress(port)); allChannels.add(channel); }
/** * The last call in the building of a RestExpress server, bind() causes Netty to bind to the * listening address and process incoming messages. * * @return Channel */ public Channel bind(int port) { setPort(port); // Configure the server. if (getIoThreadCount() == 0) { bootstrap = Bootstraps.createServerNioBootstrap(); } else { bootstrap = Bootstraps.createServerNioBootstrap(getIoThreadCount()); } // Set up the event pipeline factory. DefaultRequestHandler requestHandler = new DefaultRequestHandler(createRouteResolver(), createResponseProcessorResolver()); // Add MessageObservers to the request handler here, if desired... requestHandler.addMessageObserver(messageObservers.toArray(new MessageObserver[0])); requestHandler.setExceptionMap(exceptionMap); // Add pre/post processors to the request handler here... addPreprocessors(requestHandler); addPostprocessors(requestHandler); addFinallyProcessors(requestHandler); PipelineBuilder pf = new PipelineBuilder() .addRequestHandler(requestHandler) .setMaxContentLength(serverSettings.getMaxContentSize()); if (getExecutorThreadCount() > 0) { ExecutionHandler executionHandler = new ExecutionHandler( new OrderedMemoryAwareThreadPoolExecutor(getExecutorThreadCount(), 0, 0)); pf.setExecutionHandler(executionHandler); } bootstrap.setPipelineFactory(pf); setBootstrapOptions(); // Bind and start to accept incoming connections. if (shouldUseSystemOut()) { System.out.println("Starting " + getName() + " Server on port " + port); } Channel channel = bootstrap.bind(new InetSocketAddress(port)); allChannels.add(channel); bindPlugins(); return channel; }
@Override public void start(final boolean localOnly, final boolean anyAddress) { final int port = getPort(); log.debug("Starting proxy on port: " + port); final HttpServerPipelineFactory factory = new StatsTrackingHttpServerPipelineFactory( authenticationManager, this.allChannels, this.chainProxyManager, new StatsTrackingDefaultRelayPipelineFactoryFactory( chainProxyManager, this.responseFilters, this.requestFilter, this.allChannels, this.timer), this.clientChannelFactory, this.timer, this.handshakeHandlerFactory); serverBootstrap.setPipelineFactory(factory); // Binding only to localhost can significantly improve the security of // the proxy. InetSocketAddress isa; if (localOnly) { isa = new InetSocketAddress("127.0.0.1", port); } else if (anyAddress) { isa = new InetSocketAddress(port); } else { try { isa = new InetSocketAddress(NetworkUtils.getLocalHost(), port); } catch (final UnknownHostException e) { log.error("Could not get local host?", e); isa = new InetSocketAddress(port); } } final Channel channel = serverBootstrap.bind(isa); allChannels.add(channel); Runtime.getRuntime() .addShutdownHook( new Thread( new Runnable() { @Override public void run() { stop(); } })); log.debug("Started " + this); }
@Override public synchronized void stop() { try { accepted.close().awaitUninterruptibly(10, TimeUnit.SECONDS); ServerBootstrap bootstrap = new ServerBootstrap(selector); bootstrap.releaseExternalResources(); pipelineFact.destroy(); localFS.close(); } catch (Throwable t) { LOG.error(t); } finally { super.stop(); } }
@Override public void stop() throws Throwable { // Close all open connections shuttingDown = true; targetCallExecutor.shutdown(); targetCallExecutor.awaitTermination(10, TimeUnit.SECONDS); unfinishedTransactionExecutor.shutdown(); unfinishedTransactionExecutor.awaitTermination(10, TimeUnit.SECONDS); silentChannelExecutor.shutdown(); silentChannelExecutor.awaitTermination(10, TimeUnit.SECONDS); channelGroup.close().awaitUninterruptibly(); bootstrap.releaseExternalResources(); }
public void stop() { try { for (ChannelFutureListener listener : closingListeners) { try { listener.operationComplete(null); } catch (Exception e) { LOG.error(e); } } } finally { try { openChannels.close().awaitUninterruptibly(); } finally { channelFactory.releaseExternalResources(); } } }
// TODO change AbstractService to throw InterruptedException @Override public synchronized void start() { Configuration conf = getConfig(); ServerBootstrap bootstrap = new ServerBootstrap(selector); try { pipelineFact = new HttpPipelineFactory(conf); } catch (Exception ex) { throw new RuntimeException(ex); } bootstrap.setPipelineFactory(pipelineFact); port = conf.getInt(ConfVars.PULLSERVER_PORT.varname, ConfVars.PULLSERVER_PORT.defaultIntVal); Channel ch = bootstrap.bind(new InetSocketAddress(port)); accepted.add(ch); port = ((InetSocketAddress) ch.getLocalAddress()).getPort(); conf.set(ConfVars.PULLSERVER_PORT.varname, Integer.toString(port)); pipelineFact.PullServer.setPort(port); LOG.info(getName() + " listening on port " + port); super.start(); sslFileBufferSize = conf.getInt(SUFFLE_SSL_FILE_BUFFER_SIZE_KEY, DEFAULT_SUFFLE_SSL_FILE_BUFFER_SIZE); }