org.jboss.msc.service.StopContext Java Examples

/** {@inheritDoc} */
@Override
public synchronized void stop(final StopContext context) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            try {
                StreamUtils.safeClose(connection);
                responseAttachmentSupport.shutdown();
            } finally {
                context.complete();
            }
        }
    };
    try {
        executor.execute(r);
    } catch (RejectedExecutionException e) {
        r.run();
    } finally {
        context.asynchronous();
    }
}
 

@Override
public synchronized void stop(final StopContext stopContext) {
    final ExecutorService executorService = executorSupplier.get();
    final Runnable task = new Runnable() {
        @Override
        public void run() {
            try {
                responseAttachmentSupport.shutdown();
            } finally {
                StreamUtils.safeClose(client);
                client = null;
                stopContext.complete();
            }
        }
    };
    try {
        executorService.execute(task);
    } catch (RejectedExecutionException e) {
        task.run();
    } finally {
        stopContext.asynchronous();
    }
}
 

private void stopDone() {
    synchronized (stopLock) {
        final StopContext stopContext = this.stopContext;
        this.stopContext = null;
        if (stopContext != null) {
            stopContext.complete();
        }
        stopLock.notifyAll();
    }
}
 

public void stop(final StopContext context) {
    final ManagedJBossThreadPoolExecutorService executor;
    synchronized (this) {
        executor = this.executor;
        this.executor = null;
    }
    context.asynchronous();
    executor.internalShutdown();
    executor.addShutdownListener(StopContextEventListener.getInstance(), context);
}
 

@Override
public void stop(StopContext stopContext) {
    this.thread.interrupt();

    this.watchers.entrySet().forEach(e -> {
        try {
            e.getValue().stop();
        } catch (Exception ex) {
            ConsulTopologyMessages.MESSAGES.errorStoppingCatalogWatcher(e.getKey(), ex);
        }
    });
}
 

public synchronized void stop(final StopContext context) {
    final DeploymentUnit deploymentUnitContext = deploymentUnit;
    final DeployerChains chains = deployerChainsInjector.getValue();
    final List<RegisteredDeploymentUnitProcessor> list = chains.getChain(phase);
    final ListIterator<RegisteredDeploymentUnitProcessor> iterator = list.listIterator(list.size());
    while (iterator.hasPrevious()) {
        final RegisteredDeploymentUnitProcessor prev = iterator.previous();
        safeUndeploy(deploymentUnitContext, phase, prev);
    }
}
 

public void stop(final StopContext context) {
    plugInLoaderServiceConsumer.accept(null);
    // Clear any cached data so it can be reloaded on next start.
    cachedProviders.clear();
    authenticationProviders.clear();
    authorizationProviders.clear();
}
 

@Override
public void stop(final StopContext context) {
    try {
        context.execute(new Runnable() {
            @Override
            public void run() {
                connectionManagerRegistry.removeLdapConnectionManagerService(name);
                ldapConnectionManagerConsumer.accept(null);
                context.complete();
            }
        });
    } finally {
        context.asynchronous();
    }
}
 

@Override
public synchronized void stop(StopContext context) {
    for (JarFile jarFile : jarFiles) {
        log.debugf("Closing %s jar file which was added as resource root for %s module identifier", jarFile.getName(), moduleIdentifier.getName());
        VFSUtils.safeClose(jarFile);
    }
    jarFiles.clear();
    jarFiles = null;
    moduleDefinition = null;
}
 

@Override
public void stop(final StopContext context) {
    ROOT_LOGGER.debugf("Stopping '%s' Security Realm Service", name);
    if (securityRealmConsumer != null) {
        // TODO: eliminate above null check when WildFly code base is migrated to new MSC API
        securityRealmConsumer.accept(null);
    }
    registeredServices.clear();
    saslAuthenticationFactory = null;
    httpAuthenticationFactory.shutdownAuthenticationMechanismFactory();
    httpAuthenticationFactory = null;
}
 

@Override
public void stop(StopContext stopContext) {
    ROOT_LOGGER.tracef(
            "stopping:  keyStore = %s  unmodifiableKeyStore = %s  trackingKeyStore = %s  pathResolver = %s",
            keyStore, unmodifiableKeyStore, trackingKeyStore, pathResolver
    );
    keyStore = null;
    unmodifiableKeyStore = null;
    trackingKeyStore = null;
    if (pathResolver != null) {
        pathResolver.clear();
        pathResolver = null;
    }
}
 

@Override
public void stop(StopContext stopContext) {

    ROOT_LOGGER.tracef(
            "stopping:  filteringKeyStore = %s  modifiableFilteringKeyStore = %s",
            filteringKeyStore, modifiableFilteringKeyStore
    );

    filteringKeyStore = null;
    modifiableFilteringKeyStore = null;
}
 

public void stop(final StopContext context) {
    capabilityRegistry.clear();
    capabilityRegistry.publish();
    ServiceNameFactory.clearCache();
    controller = null;
    stabilityMonitor = null;
    processState.setStopping();
    Runnable r = new Runnable() {
        @Override
        public void run() {
            try {
                stopAsynchronous(context);
            } finally {
                try {
                    authorizer.shutdown();
                } finally {
                    context.complete();
                }
            }
        }
    };
    final ExecutorService executorService = this.executorService != null ? this.executorService.get() : null;
    try {
        if (executorService != null) {
            try {
                executorService.execute(r);
            } catch (RejectedExecutionException e) {
                r.run();
            }
        } else {
            Thread executorShutdown = new Thread(r, getClass().getSimpleName() + " Shutdown Thread");
            executorShutdown.start();
        }
    } finally {
        processState.setStopped();
        context.asynchronous();
    }
}
 

@Override
public synchronized void stop(final StopContext context) {
    serviceConsumer.accept(null);
    listenerRegistrySupplier.get().getListener(httpConnectorName).removeHttpUpgradeMetadata(httpUpgradeMetadata);
    httpUpgradeMetadata = null;
    upgradeRegistrySupplier.get().removeProtocol(JBOSS_REMOTING);
}
 

@Override
public void stop(StopContext context) {
    this.stopContext = context;
    context.asynchronous();
    worker.shutdown();
    worker = null;
}
 

@Override
public void stop(StopContext context) {
    try {
        this.server.stop();
    } catch (ServerLifecycleException | InterruptedException e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public void stop(final StopContext context) {
    synchronized (serverInventoryLock) {
        try {
            serverInventory = null;
            serverInventoryLock.set(false);
        } finally {
            serverInventoryLock.notifyAll();
        }
    }
    extensionRegistry.clear();
    domainConfigAvailable.set(false);
    super.stop(context);
}
 

@Override
public void stop(StopContext context) {
    Collections.reverse(bootstraps);
    for (SpringCamelContextBootstrap bootstrap: bootstraps) {
        List<SpringCamelContext> camelctxList = bootstrap.getSpringCamelContexts();
        for (CamelContext camelctx : camelctxList) {
            try {
                camelctx.close();
            } catch (Exception ex) {
                LOGGER.warn("Cannot stop camel context: " + camelctx.getName(), ex);
            }
        }
    }
}
 

@Override
public void stop(StopContext context) {
    synchronized (deployments) {
        for (DeploymentManager deploymentManager : deployments.values()) {
            undeploy(deploymentManager);
        }
        deployments.clear();
    }
}
 

@Override
public void stop(StopContext stopContext) {
    if (ROOT_LOGGER.isTraceEnabled()) {
        ROOT_LOGGER.tracef("stopping CredentialStore:  name = %s  credentialStore = %s", name, credentialStore.get());
    }
    if (callbackHandle != null) {
        callbackHandle.remove();
    }
    credentialStore.set(null);
}
 

@Override
public void stop(StopContext stopContext) {
    this.thread.interrupt();

    this.watchers.values().forEach(e -> {
        try {
            e.stop();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    });
}
 

@Override
public void stop(StopContext context) {
    String prettyVersion = environment.getProductConfig().getPrettyVersionString();
    //Moved to AbstractControllerService.stop()
    //processState.setStopping();
    ServerLogger.AS_ROOT_LOGGER.serverStopped(prettyVersion, Integer.valueOf((int) (context.getElapsedTime() / 1000000L)));
    BootstrapListener.deleteStartupMarker(environment.getDomainTempDir());
}
 

public void stop(final StopContext context) {
  context.asynchronous();
  executorInjector.getValue().submit(new Runnable() {
    public void run() {
      try {
        performUndeployment();
      } finally {
        context.complete();
      }
    }
  });
}
 

@Override
public synchronized void stop(final StopContext context) {

    if (executorService != null) {
        context.asynchronous();
        Thread executorShutdown = new Thread(new Runnable() {
            @Override
            public void run() {
                boolean interrupted = false;
                try {
                    executorService.shutdown();
                    // Hack. Give in progress tasks a brief period to complete before we
                    // interrupt threads via shutdownNow
                    executorService.awaitTermination(100, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    interrupted = true;
                } finally {
                    try {
                        List<Runnable> tasks = executorService.shutdownNow();
                        executorService = null;
                        if (!interrupted) {
                            for (Runnable task : tasks) {
                                ServerLogger.AS_ROOT_LOGGER.debugf("%s -- Discarding unexecuted task %s", getClass().getSimpleName(), task);
                            }
                        }
                    } finally {
                        context.complete();
                    }
                }
            }
        }, "ServerExecutorService Shutdown Thread");
        executorShutdown.start();
    }
}
 

@Override
public void stop(final StopContext context) {
    streamServerConsumer.accept(null);
    IoUtils.safeClose(streamServer);
    SocketBindingManager sbm = socketBindingManagerSupplier != null ? socketBindingManagerSupplier.get() : null;
    if (sbm != null && managedBinding != null) {
        unregisterSocketBinding(managedBinding, sbm);
    }
}
 

public void stop(final StopContext context) {
    final ManagedEnhancedQueueExecutor executor;
    synchronized (this) {
        executor = this.executor;
        this.executor = null;
    }
    context.asynchronous();
    executor.internalShutdown();
    executor.addShutdownListener(StopContextEventListener.getInstance(), context);
}
 

@Override
public void stop(StopContext context) {
    Iterator<String> namesIterator = registeredProviderNames.iterator();
    SecurityActions.doPrivileged((PrivilegedAction<Void>) () -> {
        while (namesIterator.hasNext()) {
            Security.removeProvider(namesIterator.next());
            namesIterator.remove();
        }
        return null;
    });
}
 

public void stop(StopContext context) {
    properties.clear();
    properties = null;
    propertiesFile = null;
}
 

@Override
public synchronized void stop(final StopContext context) {
    undertow.stop();
    undertow = null;
}
 

protected void stopAsynchronous(StopContext context)  {
    pingScheduler.shutdownNow();
}