stop sync on a ufs uri.

@param ufsUri the ufs uri to stop monitoring for sync
358977
@Override
  public void stopSync(AlluxioURI ufsUri) {
    LOG.debug("attempt to remove {} from sync point list", ufsUri.toString());
    mUfsUriList.remove(ufsUri);
  }
1332736
public static boolean isHdfsUri(String uriStr)
    {
        return isHdfsUri(URI.create(PERCENT.matcher(uriStr).replaceAll("")));
    }
330926
public synchronized void stop() {
		if (writer != null) {
			try {
				writer.close(headerBytes);
				writer = null;
			} catch (IOException ex) {
				// No need to crash on this error even if the tail won't be written
				// since reading logic can take care of that.
			}
		}
		// Ensure that timer is stopped as well.
		disableFileSwitch();
		
		headerBytes = null;
		// Don't stop manager here since it can be reused for a different repository writer.
		//manager.stop();
	}
24784
public void stop() {

    reflector.stop();
    reflectorFuture.cancel(true);
    reflectExecutor.shutdown();

    if (resyncFuture != null) {
      resyncFuture.cancel(true);
      resyncExecutor.shutdown();
    }
  }
1241024
public void delete(URI uri, Credentials credentials) throws IOException {
		delete(uri, null, credentials);
	}
1265904
def stop_sync(self):
        """"""
        # Stop to scan
        if self.scanning:
            self.stop_scan()

        # Disconnect all connected devices
        for connection_id in list(self.connections.get_connections()):
            self.disconnect_sync(connection_id)

        # Stop the baBLE interface
        self.bable.stop()
        # Stop the connection manager
        self.connections.stop()

        self.stopped = True
1200459
@SuppressWarnings("WeakerAccess")
    public synchronized void stop() {
        if (isRunning()) {
            running.set(false);
            MetadataFinder.getInstance().removeMetadataProvider(metadataProvider);
            for (Database database : databases.values()) {
                //noinspection ResultOfMethodCallIgnored
                database.sourceFile.delete();
            }
            databases.clear();
        }
    }
261533
public static synchronized void stopUpload(final String uploadId) {
        UploadTask removedTask = uploadTasksMap.get(uploadId);
        if (removedTask != null) {
            removedTask.cancel();
        }
    }
8357
@SuppressWarnings("unused") // called via reflection
  public static Runnable removeFileSystemRunnable(final URI uri) {
    return new Runnable() {
      @Override
      public void run() {
        fileSystems.remove(uri);
      }
    };
  }
601099
public void setDefaultUri(String defaultUri) {

        if (m_frozen) {
            throw new CmsRuntimeException(Messages.get().container(Messages.ERR_CONFIG_FROZEN_0));
        }
        m_defaultUri = defaultUri;
    }
121895
def _disconnected(self, uri):
        """"""
        self.param_updater.close()
        self.is_updated = False
        # Clear all values from the previous Crazyflie
        self.toc = Toc()
        self.values = {}
959123
def stop_sync(self):
        

        conn_ids = self.conns.get_connections()

        # If we have any open connections, try to close them here before shutting down
        for conn in list(conn_ids):
            try:
                self.disconnect_sync(conn)
            except HardwareError:
                pass

        self.client.disconnect()
        self.conns.stop()
813438
def stop_sync(self):
        """"""

        if self._control_thread is not None and self._control_thread.is_alive():
            self._control_thread.stop()
            self._control_thread.join()

        if self.jlink is not None:
            self.jlink.close()
1300176
@Override
  public void startSync(AlluxioURI ufsUri) {
    LOG.debug("Add {} as a sync point", ufsUri.toString());
    mUfsUriList.add(ufsUri);
  }
692094
public void stopStep() {
        final String root = threadContext.getRoot().orElse(null);
        final Optional<String> current = threadContext.getCurrent()
                .filter(uuid -> !Objects.equals(uuid, root));
        if (!current.isPresent()) {
            LOGGER.error("Could not stop step: no step running");
            return;
        }
        final String uuid = current.get();
        stopStep(uuid);
    }
197194
@Override
    public void stop() {
        if(isStarted.compareAndSet(true,false)){
            healthCheckService.shutdown();
            heartbeatService.shutdown();
        }
    }
911495
public void stop() {
    if (stopRequested) {
      return;
    }
    stopRequested = true;
    running = false;
    if (server != null) server.stop();
    if (triggerThread != null) {
      triggerThread.interrupt();
      triggerMonitor = null;
    }
    if (urfThread != null) {
      urfThread.interrupt();
      urfProcessor = null;
    }
    if (blockIntegrityMonitor != null) blockIntegrityMonitor.running = false;
    if (blockFixerThread != null) blockFixerThread.interrupt();
    if (blockCopierThread != null) blockCopierThread.interrupt();
    if (corruptFileCounterThread != null) corruptFileCounterThread.interrupt();
    if (purgeMonitor != null) purgeMonitor.running = false;
    if (purgeThread != null) purgeThread.interrupt();
    if (placementMonitor != null) placementMonitor.stop();
    if (statsCollector != null) statsCollector.stop();
    if (statsCollectorThread != null) statsCollectorThread.interrupt();
    if (infoServer != null) {
      try {
        infoServer.stop();
      } catch (Exception e) {
        LOG.warn("Exception shutting down " + RaidNode.class, e);
      }
    }
    this.unregisterMBean();
  }