Closes all pooled tracers.
2630
public void closePoolTracer() {
    this.poolWriteLock.lock();
    try {
      for (AbstractTracer tracer : this.tracerPool.values()) {
        tracer.close();
      }
    }
    finally {
      this.poolWriteLock.unlock();
    }
  }
205384
private void closeAll(){
        Feeder feeder = this;
        while(feeder.parent!=null)
            feeder = feeder.parent;
        while(feeder!=null){
            try{
                if(feeder.channel!=null)
                    feeder.channel.close();
            }catch(IOException ignore){
                // ignore
            }
            feeder = feeder.child;
        }
    }
945451
public void close() {
    if (pool != null)
      pool.close();

    pool = null;
    if (shouldCloseOrientDB) {
      factory.close();
    }
  }
1012024
def close(self):
        """"""
        for tif in self._files.values():
            tif.filehandle.close()
        self._files = {}
414788
@Override
  public void close() {
    if (isClosed())
      return;

    vertexBaseClass = null;
    edgeBaseClass = null;

    checkOpeness();
    rollback();

    getMetadata().close();
    ((ODatabaseRaw) underlying.getUnderlying()).callOnCloseListeners();
    getLevel1Cache().clear();

    final OGraphDatabasePool pool = ownerPool;
    ownerPool = null;
    pool.release(this);
  }
324168
def close(self):
        
        self.pool.close()
        self.pool.terminate()
        self.pool.join()
972025
public void closeAll() {

        // Close any active streams
        for (InterceptedStream<T> stream : streams.values())
            close(stream.getStream());

        // Remove now-useless references
        streams.clear();

    }

    /**
     * Blocks until the given stream is closed, or until another stream with
     * the same index replaces it.
     *
     * @param stream
     *     The stream to wait for.
     */
    public void waitFor(InterceptedStream<T> stream) {

        T underlyingStream = stream.getStream();

        // Wait for stream to close
        synchronized (underlyingStream) {
            while (streams.get(stream.getIndex()) == stream) {
                try {
                    underlyingStream.wait(STREAM_WAIT_TIMEOUT);
                }
                catch (InterruptedException e) {
                    // Ignore
                }
            }
        }

    }

    /**
     * Returns the stream stored in this map under the given index.
     *
     * @param index
     *     The index of the stream to return.
     *
     * @return
     *     The stream having the given index, or null if no such stream is
     *     stored within this map.
     */
    public InterceptedStream<T> get(String index) {
        return streams.get(index);
    }

    /**
     * Adds the given stream to this map, storing it under its associated
     * index. If another stream already exists within this map having the same
     * index, that stream will be closed and replaced.
     *
     * @param stream
     *     The stream to store within this map.
     */
    public void put(InterceptedStream<T> stream) {

        // Add given stream to map
        InterceptedStream<T> oldStream =
                streams.put(stream.getIndex(), stream);

        // If a previous stream DID exist, close it
        if (oldStream != null)
            close(oldStream.getStream());

    }

}
1086911
def close(self):
        """"""
        # Ensure everything is cleaned up on exit
        scoop.logger.debug('Closing workers on {0}.'.format(self))

        # Terminate subprocesses
        for process in self.subprocesses:
            try:
                process.terminate()
            except OSError:
                pass
486601
final void closeAndRemoveAllDatabaseHandles() {
        for (Database databaseHandle : this.databaseHandles) {
            try {
                databaseHandle.close();
            } catch (EnvironmentFailureException | IllegalStateException ex) {
                LOGGER.log(Level.SEVERE,
                        "Error closing databases", ex);
            }
        }
        this.databaseHandles.clear();
    }
445732
public void releaseAllResources()
    {
        synchronized (poolSynch)
        {
            Collection pools = poolMap.values();
            poolMap = new HashMap(poolMap.size());
            ObjectPool op = null;
            for (Iterator iterator = pools.iterator(); iterator.hasNext();)
            {
                try
                {
                    op = ((ObjectPool) iterator.next());
                    op.close();
                }
                catch (Exception e)
                {
                    log.error("Exception occured while closing pool " + op, e);
                }
            }
        }
        super.releaseAllResources();
    }
1045171
def close(self):
        """"""
        self.flush()
        self.stream.close()
        logging.StreamHandler.close(self)
715296
public void close() throws IOException, InterruptedException {
        channel.close();
        channel.join();
        if (ownsPool)
            pool.shutdown();
        for (Closeable c : closables)
            c.close();
    }
1163125
public void close() {
        logger.info("Closing all sync producers");
        if (sync) {
            for (SyncProducer p : syncProducers.values()) {
                p.close();
            }
        } else {
            for (AsyncProducer<V> p : asyncProducers.values()) {
                p.close();
            }
        }

    }
1323576
def _close(self):
        '''
        
        '''
        if hasattr(self, 'aiohttp'):
            if not self.aiohttp.closed:
                self.aiohttp.close()
        if hasattr(self, 'file_descriptors'):
            for fd in self.file_descriptors.values():
                if not fd.closed:
                    fd.close()
85660
def close(self):
        
        self.poolmanager.clear()
        for proxy in self.proxy_manager.values():
            proxy.clear()
738604
def close(self):
        
        for impyla_connection in self._connections:
            impyla_connection.close()

        self._connections.clear()
        self.connection_pool.clear()
1275659
@Override
    public void closeAll() {

        closed.set(true);

        queues.stream()
              .forEach(Queue::closeAndClear);

    }