Stop import.
Terminates the current user import operation.
@throws ProvisioningApiException if the call is unsuccessful.
551907
public void terminateImport() throws ProvisioningApiException {
		try {
			ApiSuccessResponse resp = importApi.terminateImport();
			
			if (!resp.getStatus().getCode().equals(0)) {
				throw new ProvisioningApiException("Error terminating import. Code: " + resp.getStatus().getCode());
			}
			
        } catch(ApiException e) {
        	throw new ProvisioningApiException("Error terminating import", e);
        }
	}
1308688
public void stop(BundleContext bc) throws Exception {
		if (httpService != null) {
			bc.ungetService(httpServiceRef);
			httpServiceRef = null;
			httpService = null;
		}
	}
806352
@Invalidate
    public void stop() {
        unregisterConfigurationsExposedAsServices();
        if (registration != null) {
            registration.unregister();
            registration = null;
            try {
                watcher.removeAndStopIfNeeded(configFile.getParentFile());
            } catch (RuntimeException e) { //NOSONAR
                // An exception can be thrown when the platform is shutting down.
                // ignore it.
            }
        }
    }
216431
public void stop(BundleContext context) throws Exception {
        ClassServiceUtility.log(context, LogService.LOG_INFO, "Stopping ObrClassFinderImpl");

        super.stop(context);
        repositoryAdmin = null;
        waitingForRepositoryAdmin = false;
        waitingForClassService = false;
        ClassFinderActivator.setClassFinder(null);
    }
922584
protected void stop() throws Exception {
		this.logger.debug("Stopping application");
		this.stopLock.lock();
		try {
			for (ConfigurableApplicationContext context : this.rootContexts) {
				context.close();
				this.rootContexts.remove(context);
			}
			cleanupCaches();
			if (this.forceReferenceCleanup) {
				forceReferenceCleanup();
			}
		}
		finally {
			this.stopLock.unlock();
		}
		System.gc();
		System.runFinalization();
	}
540598
@Override
    public void stop() {
        synchronized (this.lifecycleMonitor) {
            if (isRunning()) {
                log.info("stop: Stopping ConnectorManager");
                try {
                    connector.stop();
                } finally {
                    running = false;
                }
            }
        }
    }
141183
void stop( Instance instance, PluginInterface plugin ) throws IOException {

		String instancePath = InstanceHelpers.computeInstancePath( instance );
		if( instance.getStatus() != InstanceStatus.DEPLOYED_STARTED )
			this.logger.fine( instancePath + " cannot be stopped. Prerequisite status: DEPLOYED_STARTED (but was " + instance.getStatus() + ")." );
		else
			stopInstance( instance, plugin, false );
	}
430745
public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }
949846
public void stop() {
    try {
      if (socket != null) {
        socket.close();
        socket = null;
        LOGGER.info("Disconnected from graphite server: {}", graphiteServerURI);
      }
    } catch (IOException e) {
      LOGGER.warn("Error Stopping", e);
    }
  }
512556
@Override
	public void stop(BundleContext context) throws Exception {
		final String sourceMethod = "stop"; //$NON-NLS-1$
		boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(Activator.class.getName(), sourceMethod, new Object[]{context});
		}
		super.stop(context);
		// Shutdown the aggregator instances
		ServiceReference<?>[] refs = context.getServiceReferences(IAggregator.class.getName(), null);
		if (refs != null) {
			for (ServiceReference<?> ref : refs) {
				AggregatorImpl aggr = (AggregatorImpl)context.getService(ref);
				if (aggr != null) {
					try {
						aggr.shutdown();
					} catch (Exception e) {
						if (log.isLoggable(Level.SEVERE)) {
							log.log(Level.SEVERE, e.getMessage(), e);
						}
					}
				}
			}
		}

		for (ServiceRegistration<?> reg : serviceRegistrations) {
			reg.unregister();
		}
		if (executors != null) {
			executors.shutdown();
		}
		this.executors = null;
		Activator.context = null;

		if (isTraceLogging) {
			log.exiting(Activator.class.getName(), sourceMethod);
		}
	}
1207789
public void stop() throws Exception {
        DruidIndices.getInstance().remove(String.valueOf(port));
        server.stop();
    }
439441
def stop(self):
        
        if not self._consumers_ready.ready():
            _log.debug('stopping while consumer is starting %s', self)

            stop_exc = QueueConsumerStopped()

            # stopping before we have started successfully by brutally
            # killing the consumer thread as we don't have a way to hook
            # into the pre-consumption startup process
            self._gt.kill(stop_exc)

        self.wait_for_providers()

        try:
            _log.debug('waiting for consumer death %s', self)
            self._gt.wait()
        except QueueConsumerStopped:
            pass

        super(QueueConsumer, self).stop()
        _log.debug('stopped %s', self)
692717
public void stop() {
      // This method might get called several times.
      if (stopped) return;
      if (needToUnregister) {
         try {
            unregisterMBeans(resourceDMBeans);
            needToUnregister = false;
         } catch (Exception e) {
            log.problemsUnregisteringMBeans(e);
         }
      }
      stopped = true;
   }
137876
private void stop() {
		for (int i = 0; i < mDownloadDispatchers.length; i++) {
			if (mDownloadDispatchers[i] != null) {
				mDownloadDispatchers[i].quit();
			}
		}
	}
789211
public void deleteUser(String userDBID, Boolean keepPlaces) throws ProvisioningApiException {
		try {
			ApiSuccessResponse resp = usersApi.deleteUser(userDBID, keepPlaces);

			if (!resp.getStatus().getCode().equals(0)) {
				throw new ProvisioningApiException("Error deleting user. Code: " + resp.getStatus().getCode());
			}
        } catch(ApiException e) {
        	throw new ProvisioningApiException("Error deleting user", e);
        }
	}
83165
protected void stop() throws Exception {
		this.started = false;
		for (ManagementEventListener lstr : this.management.getManagementEventListeners()) {
			try {
				lstr.onAssociationStopped(this);
			} catch (Throwable ee) {
				logger.error("Exception while invoking onAssociationStopped", ee);
			}
		}

		if (this.getSocketChannel() != null && this.getSocketChannel().isOpen()) {
			FastList<ChangeRequest> pendingChanges = this.management.getPendingChanges();
			synchronized (pendingChanges) {
				// Indicate we want the interest ops set changed
				pendingChanges.add(new ChangeRequest(getSocketChannel(), this, ChangeRequest.CLOSE, -1));
			}

			// Finally, wake up our selecting thread so it can make the required
			// changes
			this.management.getSocketSelector().wakeup();
		}
	}
403634
public final void stop()
    {
        m_stopping = true;

        ImmutableMap<URI, AbstractImporter> oldReference;
        boolean success = false;
        do { // onChange also could set m_importers. Use while loop to pick up latest ref
            oldReference = m_importers.get();
            success = m_importers.compareAndSet(oldReference, ImmutableMap.<URI, AbstractImporter> of());
        } while (!success);

        if (!m_starting.get()) return;

        stopImporters(oldReference.values());
        if (!m_factory.isImporterRunEveryWhere()) {
            m_distributer.registerChannels(m_distributerDesignation, Collections.<URI> emptySet());
            m_distributer.unregisterCallback(m_distributerDesignation);
        }

        if (m_executorService == null) {
            return;
        }

        //graceful shutdown to allow importers to properly process post shutdown tasks.
        m_executorService.shutdown();
        try {
            m_executorService.awaitTermination(60, TimeUnit.SECONDS);
            m_executorService = null;
        } catch (InterruptedException ex) {
            //Should never come here.
            s_logger.warn("Unexpected interrupted exception waiting for " + m_factory.getTypeName() + " to shutdown", ex);
        }
    }