Remove an NTP server entry from the node config

        Args:
            name (string): The IP address or FQDN of the NTP server.

        Returns:
            True if the operation succeeds, otherwise False.
175289
def remove_server(self, name):
        
        cmd = self.command_builder('no ntp server', value=name)
        return self.configure(cmd)
1029691
def remove_node(self, node):
        
        if _debug: Network._debug("remove_node %r", node)

        self.nodes.remove(node)
        node.lan = None
1112523
public function removeConnection(string $name)
  {
    # Sanity check
    if (empty($name)) return false;

    $connection = $this->findConnection($name);

    if ($connection) {
      $connection->disconnect();
      unset( $this->connections[\strtolower($connection->getName())] );
      unset($connection);
      $connection = null;
    }

    return \is_null($connection);
  }
956184
async def remove(self, name: str) -> None:
        

        LOGGER.debug('NodePoolManager.remove >>> name: %s', name)

        try:
            await pool.delete_pool_ledger_config(name)
        except IndyError as x_indy:
            LOGGER.info('Abstaining from node pool removal; indy-sdk error code %s', x_indy.error_code)

        LOGGER.debug('NodePool.remove <<<')
751829
public static function delete(String $name = NULL) : Bool
    {
        $name  = self::$settings['name']  ?? $name;
        $input = self::$settings['input'] ?? false;

        self::$settings = [];

        switch( $input )
        {
            case 'post'    : unset($_POST[$name]);    break;
            case 'get'     : unset($_GET[$name]);     break;
            case 'env'     : unset($_ENV[$name]);     break;
            case 'server'  : unset($_SERVER[$name]);  break;
            case 'request' : unset($_REQUEST[$name]); break;
        }

        return true;
    }
540720
def delete_namespace(self, name):
        
        self.core_api.delete_namespace(name, client.V1DeleteOptions())

        logger.info("Deleting namespace: %s", name)
475156
def unregister(self, name):
        
        try:
            name = name.name
        except AttributeError:
            pass
        return self.pop(name,None)
614694
def remove_redirect(self, name):
        
        if not isinstance(name, basestring):
            raise TypeError("name can only be an instance of type basestring")
        self._call("removeRedirect",
                     in_p=[name])
1133477
public void remove(String name) {
        EndpointService<L, S> service = endpointServices.remove(name);
        if (service != null) {
            service.stop();
            log.infoRemovedEndpointService(service.toString());
        }
    }
922443
def _remove_node(self, node_name):
        
        try:
            self._nodes.pop(node_name)
        except Exception:
            raise KeyError('node \'{}\' not found, available nodes: {}'.format(
                node_name, self._nodes.keys()))
        else:
            self._create_ring(self._nodes)
139772
def floating_ip_disassociate(self, server_name, floating_ip):
        '''
        
        '''
        nt_ks = self.compute_conn
        server_ = self.server_by_name(server_name)
        server = nt_ks.servers.get(server_.__dict__['id'])
        server.remove_floating_ip(floating_ip)
        return self.floating_ip_list()[floating_ip]
519240
def remove(name: str) -> bool:
    
    db = TinyDB(corpus_db_path())
    temp = Query()
    data = db.search(temp.name == name)

    if len(data) > 0:
        path = get_corpus_path(name)
        os.remove(path)
        db.remove(temp.name == name)
        return True

    return False
283510
def disable_node(self, service_name, node_name):
        
        logger.info("Disabling server %s/%s", service_name, node_name)
        return self.send_command(
            "disable server %s/%s" % (service_name, node_name)
        )
199489
public boolean remove(String name) {
        final AsmMetric metric = metrics.remove(name);
        if (metric != null) {
            LOG.info("Successfully unregister metric of {}", name);
            return true;
        }
        return false;
    }
225091
def remove(name=None, index=None):
    

    removed = False
    count = 1
    for configuration in _CONFIG.sections():
        if index != None:
            if count == index:
                _CONFIG.remove_section(configuration)
                removed = True
                break

        if name != None:
            if configuration == name:
                _CONFIG.remove_section(configuration)
                removed = True
                break

        count += 1

    if not removed:
        raise JutException('Unable to find %s configuration' % name)

    with open(_CONFIG_FILEPATH, 'w') as configfile:
        _CONFIG.write(configfile)
317465
def delete(self):
        
        cmd = self.command_builder('ntp source', disable=True)
        return self.configure(cmd)
1171903
def delete_network(self, name, tenant_id, subnet_id, net_id):
        
        try:
            self.neutronclient.delete_subnet(subnet_id)
        except Exception as exc:
            LOG.error("Failed to delete subnet %(sub)s exc %(exc)s",
                      {'sub': subnet_id, 'exc': str(exc)})
            return
        try:
            self.neutronclient.delete_network(net_id)
        except Exception as exc:
            LOG.error("Failed to delete network %(name)s exc %(exc)s",
                      {'name': name, 'exc': str(exc)})