/** 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();
}
/** 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();
}
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);
}
});
}
}
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");
}
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");
}
private void stopConfiguration() throws Exception {
if (configuration == null) {
// abort received but script not prepared, therefore entire script failed
if (progress == null) {
progress = new ScriptProgress(newSequential(0, 0), "");
}
RegionInfo scriptInfo = progress.getScriptInfo();
progress.addScriptFailure(scriptInfo);
} else {
// stopping the configuration will implicitly trigger the script complete listener
// to handle incomplete script that is being aborted by canceling the finish future
// clear out the pipelines for new connections to avoid impacting the observed script
for (ServerBootstrapResolver serverResolver : configuration.getServerResolvers()) {
ServerBootstrap server = serverResolver.resolve();
server.setPipelineFactory(pipelineFactory(pipeline(closeOnExceptionHandler)));
}
for (ClientBootstrapResolver clientResolver : configuration.getClientResolvers()) {
ClientBootstrap client = clientResolver.resolve();
client.setPipelineFactory(pipelineFactory(pipeline(closeOnExceptionHandler)));
}
// remove each handler from the configuration pipelines
// this will trigger failures for any handlers on a pipeline for an incomplete stream
// including pipelines not yet associated with any channel
for (ChannelPipeline pipeline : configuration.getClientAndServerPipelines()) {
stopStream(pipeline);
}
// cancel any pending binds and connects
for (ChannelFuture bindFuture : bindFutures) {
bindFuture.cancel();
}
for (ChannelFuture connectFuture : connectFutures) {
connectFuture.cancel();
}
// close server and client channels
final ChannelGroupFuture closeFuture = serverChannels.close();
closeFuture.addListener(
new ChannelGroupFutureListener() {
@Override
public void operationComplete(final ChannelGroupFuture future) {
clientChannels.close();
}
});
for (AutoCloseable resource : configuration.getResources()) {
try {
resource.close();
} catch (Exception e) {
// ignore
}
}
}
}
/** Frees all the server resources. */
@Override
public void shutdown() {
// Close all connections.
ChannelGroupFuture groupFuture = NeddyBenchmark.getAllChannels().close();
groupFuture.awaitUninterruptibly();
// Shutdown the selector loop (boss and workers).
getBootstrap().getFactory().releaseExternalResources();
}
public void stop() {
try {
myScheduler.shutdown();
myBuildsExecutor.shutdown();
final ChannelGroupFuture closeFuture = myAllOpenChannels.close();
closeFuture.awaitUninterruptibly();
} finally {
myChannelFactory.releaseExternalResources();
}
}
/**
* 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();
}
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();
}
/** 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);
}
}
@Override
public final boolean isCompleteSuccess() {
ensureConditionSet();
if (condition) {
return backedChannelGroupFuture.isCompleteSuccess();
}
return false;
}
@Override
public final boolean isPartialFailure() {
ensureConditionSet();
if (condition) {
return backedChannelGroupFuture.isPartialFailure();
}
return false;
}
@Override
public boolean isSuccessful() {
if (groupFuture != null) {
return groupFuture.isCompleteSuccess();
} else {
return false;
}
}
@Override
public final boolean isCompleteFailure() {
ensureConditionSet();
if (condition) {
return backedChannelGroupFuture.isCompleteFailure();
}
return true;
}
@Override
public final ChannelGroupFuture awaitUninterruptibly() {
waitForConditionSetUninterruptibly(-1, -1);
if (condition) {
backedChannelGroupFuture.awaitUninterruptibly();
}
return this;
}
@Override
public final Iterator<ChannelFuture> iterator() {
ensureConditionSet();
if (condition) {
return backedChannelGroupFuture.iterator();
} else {
return null;
}
}
@Override
public final ChannelGroup getGroup() {
ensureConditionSet();
if (condition) {
return backedChannelGroupFuture.getGroup();
} else {
return EMPTY_GROUP;
}
}
@Override
public final ChannelFuture find(final Integer channelId) {
ensureConditionSet();
if (condition) {
return backedChannelGroupFuture.find(channelId);
} else {
return null;
}
}
@Override
public final ChannelGroupFuture await() throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
}
waitForConditionSet(-1, -1);
if (condition) {
backedChannelGroupFuture.await();
}
return this;
}
@Override
public final boolean isDone() {
if (!conditionSetFlag) {
return false;
} else {
if (condition) {
return backedChannelGroupFuture.isDone();
} else {
return true;
}
}
}
@Override
public final void removeListener(final ChannelGroupFutureListener listener) {
synchronized (conditionSetLock) {
if (!conditionSetFlag) {
listeners.remove(listener);
}
}
if (conditionSetFlag) {
if (condition) {
backedChannelGroupFuture.removeListener(listener);
}
}
}
@Override
public final boolean awaitUninterruptibly(final long timeout, final TimeUnit unit) {
final long nano = unit.toNanos(timeout);
final long milli = NANOSECONDS.toMillis(nano);
final int nanoRemain = (int) (nano - MILLISECONDS.toNanos(milli));
final long remain = nano - waitForConditionSetUninterruptibly(milli, nanoRemain);
if (conditionSetFlag) {
if (condition) {
return backedChannelGroupFuture.awaitUninterruptibly(remain, NANOSECONDS);
} else {
return true;
}
} else {
return false;
}
}
@Override
public final void addListener(final ChannelGroupFutureListener listener) {
synchronized (conditionSetLock) {
if (!conditionSetFlag) {
listeners.put(listener, listener);
return;
}
}
if (condition) {
backedChannelGroupFuture.addListener(listener);
} else {
try {
listener.operationComplete(this);
} catch (final Throwable t) {
LOGGER.warn("Exception occured when executing ChannelGroupFutureListener", t);
}
}
}
/**
* Set the condition value.
*
* @param conditionSatisfied if the condition is satisfied.
*/
public final void setCondition(final boolean conditionSatisfied) {
synchronized (conditionSetLock) {
condition = conditionSatisfied;
conditionSetFlag = true;
if (condition) {
for (final ChannelGroupFutureListener l : listeners.keySet()) {
backedChannelGroupFuture.addListener(l);
}
listeners.clear();
} else {
for (final ChannelGroupFutureListener l : listeners.keySet()) {
try {
l.operationComplete(this);
} catch (final Throwable t) {
LOGGER.warn("Exception occured when executing ChannelGroupFutureListener", t);
}
}
}
conditionSetLock.notifyAll();
}
}
/**
* Releases all resources associated with this server so the JVM can shutdown cleanly. Call this
* method to finish using the server. To utilize the default shutdown hook in main() provided by
* RestExpress, call awaitShutdown() instead.
*/
public void shutdown() {
ChannelGroupFuture future = allChannels.close();
future.awaitUninterruptibly();
shutdownPlugins();
bootstrap.getFactory().releaseExternalResources();
}
public void stopListening() {
final ChannelGroupFuture closeFuture = myAllOpenChannels.close();
closeFuture.awaitUninterruptibly();
}