Deletes an engine pool

 @param [Connection] conn Connection to console where site exists.
480011
def delete(conn)
      xml = conn.make_xml('EnginePoolDeleteRequest')
      xml.add_element(as_xml)
      result = conn.execute(xml, '1.2')
      result.success
    end
574808
protected void removeConnection(FTPConnection con) throws IOException {
        synchronized(listeners) {
            for(IFTPListener l : listeners) {
                l.onDisconnected(con);
            }
        }
        synchronized(connections) {
            connections.remove(con);
        }
    }
1004466
def delete_connection(self, **kwargs):
        """"""
        conn = self.find_connection(**kwargs)
        if not conn:
            return False
        self.delete(conn)
        return True
568159
function(conn, cb) {
      log.debug('teardown:', conn);
      /* istanbul ignore if: standard waterline-adapter code */
      if ( typeof conn == 'function') {
        cb = conn;
        conn = null;
      }
      /* istanbul ignore if: standard waterline-adapter code */
      if (!conn) {
        connections = {};
        return cb();
      }
      /* istanbul ignore if: standard waterline-adapter code */
      if (!connections[conn])
        return cb();
      delete connections[conn];
      cb();
    }
889684
private void cleanupConnection(Connection conn, ResultSet rs, PreparedStatement statement) {

		logger.logp(Level.FINEST, CLASSNAME, "cleanupConnection", "Entering",  new Object[] {conn, rs==null ? "<null>" : rs, statement==null ? "<null>" : statement});

		if (statement != null) {
			try {
				statement.close();
			} catch (SQLException e) {
				throw new PersistenceException(e);
			}
		}

		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				throw new PersistenceException(e);
			}
		}

		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				throw new PersistenceException(e);
			} finally {
				try {
					conn.close();
				} catch (SQLException e) {
					throw new PersistenceException(e);
				}
			}
		}
		logger.logp(Level.FINEST, CLASSNAME, "cleanupConnection", "Exiting");
	}
243093
public MPConnection removeConnection(MEConnection conn)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "removeConnection", new Object[] { conn });

    MPConnection mpConn;
    synchronized(_mpConnectionsByMEConnection)
    {
      //remove the MPConnection from the 'by MEConnection' cache
      mpConn = _mpConnectionsByMEConnection.remove(conn);
      if(mpConn != null)
      {
        //remove it from the 'by cellule' cache also
        _mpConnectionsByMEUuid.remove(mpConn.getRemoteMEUuid());
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeConnection", mpConn);
  
    return mpConn;
  }
747020
def delete_namespace(self):
        '''

        '''
        conn = redis.Redis(connection_pool=self.pool)
        keys = conn.keys("%s*" % self._namespace_str)
        for i in xrange(0, len(keys), 10000):
            conn.delete(*keys[i:i+10000])
        logger.debug('tearing down %r', self._namespace_str)
1339242
def delete(url, options = {})
      connection(url, options) do |uri, conn|
        conn.delete(uri.request_uri, options)
      end
    end
887997
function (conn, cb) {

      // TODO: disconnect here
      if (typeof conn == 'function') {
        cb = conn;
        conn = null;
      }
      if (!conn) {
        connections = {};
        return cb();
      }
      if(!connections[conn]) return cb();
      delete connections[conn];
      cb();
    }
253544
def terminate_pool(self):
        """"""

        if self.pool is not None:
            self.pool.terminate()
            self.pool.join()
            del(self.pool)
            self.pool = None
384568
def remove(t)
      raise ArgumentError.new('Expecting an ActionPool::Thread object') unless t.is_a?(ActionPool::Thread)
      del = @threads.include?(t)
      @threads.delete(t) if del
      fill_pool
      t.stop
      del
    end
884696
public static synchronized void clearConnection(String poolName, Object mcp, Object cl, Object connection)
   {
      log.tracef("%s", new TraceEvent(poolName,
                                      Integer.toHexString(System.identityHashCode(mcp)),
                                      TraceEvent.CLEAR_CONNECTION,
                                      Integer.toHexString(System.identityHashCode(cl)),
                                      Integer.toHexString(System.identityHashCode(connection))));
   }
976501
def clean(self):
        
        LOGGER.debug('Cleaning the pool')
        for connection in [self.connections[k] for k in self.connections if
                           self.connections[k].closed]:
            LOGGER.debug('Removing %s', connection.id)
            self.remove(connection.handle)

        if self.idle_duration > self.idle_ttl:
            self.close()

        LOGGER.debug('Pool %s cleaned', self.id)
552035
protected void releaseConnection(Object conn)
    {
        clientFactory.releaseConnection(((Connection) conn).getPool(), ((Connection) conn).getClient());
    }
535376
private void remove(PollController conn)
  {
    if (conn == null) {
      return;
    }

    if (_lifecycle.isDestroyed()) {
      return;
    }

    _activeCount.incrementAndGet();

    if (_activeCount.decrementAndGet() == 0 && _lifecycle.isDestroyed()) {
      destroy();
    }
  }
116213
public void unregisterPool(ManagedConnectionPool mcp)
   {
      synchronized (registeredPools)
      {
         registeredPools.values().remove(mcp);
      
         if (registeredPools.isEmpty()) 
            interval = Long.MAX_VALUE;
      }
   }
530961
def delete(key)
      deleted = false
      pool = nil
      @mutex.synchronize do
        pool = @_sessions.delete(key)
      end
      if pool
        pool.shutdown!
        deleted = true
        HotTub.logger.info "[HotTub] #{key} was deleted from #{@name}." if HotTub.logger
      end
      deleted
    end