Delete existing servers
@param servers the array of servers to delete
@return OperationFuture wrapper for list of ServerRef
422167
public OperationFuture<List<Server>> delete(Server... servers) {
        List<JobFuture> futures = Arrays.asList(servers).stream()
            .map(serverRef -> delete(serverRef).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            Arrays.asList(servers),
            new ParallelJobsFuture(futures)
        );
    }
431063
private void normalizeModel(List<Server> servers) {

        for (Server server : servers) {
            ServerInstance serverInstance = getServerInstance(new ServerRef(server.getHostName(), server.getName()));
            server.setServerState(serverInstance.getServerState());
            server.setSuspendState(serverInstance.getSuspendState());
        }
    }
48003
public void removeServerSocket(
      InternalInstrumented<ServerStats> server, InternalInstrumented<SocketStats> socket) {
    ServerSocketMap socketsOfServer = perServerSockets.get(id(server));
    assert socketsOfServer != null;
    remove(socketsOfServer, socket);
  }
1121507
public OperationFuture<List<FirewallPolicy>> delete(FirewallPolicy... firewallPolicies) {
        return delete(Arrays.asList(firewallPolicies));
    }
1298216
public final B serverAddresses(Iterable<InetSocketAddress> serverAddresses) {
        requireNonNull(serverAddresses, "serverAddresses");
        final DnsServerAddresses addrs = DnsServerAddresses.sequential(serverAddresses);
        serverAddressStreamProvider = hostname -> addrs.stream();
        return self();
    }
302266
public OperationFuture<List<Server>> removeAutoscalePolicyOnServer(List<Server> serverList) {
        List<JobFuture> jobs = serverList
            .stream()
            .map(server -> removeAutoscalePolicyOnServer(server).jobFuture())
            .collect(toList());

        return
            new OperationFuture<>(
                serverList,
                new ParallelJobsFuture(jobs)
            );
    }
739347
public OperationFuture<Server> removePublicIp(Server serverRef) {
        checkNotNull(serverRef, "Server reference must be not null");
        ServerMetadata serverMetadata = findByRef(serverRef);

        List<JobFuture> jobFutures = serverMetadata.getDetails().getIpAddresses()
            .stream()
            .map(IpAddress::getPublicIp)
            .filter(notNull())
            .map(address -> removePublicIp(serverRef, address).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            serverRef,
            new ParallelJobsFuture(jobFutures)
        );
    }
1072053
public OperationFuture<Group> delete(Group group) {
        Link response = client.deleteGroup(idByRef(group));

        return new OperationFuture<>(
                group,
                response.getId(),
                queueClient
        );
    }
1031742
public OperationFuture<List<Server>> reboot(Server... serverRefs) {
        return powerOperationResponse(
            Arrays.asList(serverRefs),
            "Reboot",
            client.reboot(ids(serverRefs))
        );
    }
1337281
public OperationFuture<List<Server>> stopMaintenance(Group... groups) {
        return serverService().stopMaintenance(
            getServerSearchCriteria(groups)
        );
    }
86772
public OperationFuture<List<LoadBalancer>> delete(LoadBalancer... loadBalancer) {
        return delete(Arrays.asList(loadBalancer));
    }
438712
def server_delete(endpoint_id, server):
    
    client = get_client()

    mode = _detect_mode(server)

    # list (even if not necessary) in order to make errors more consistent when
    # mode='id'
    endpoint, server_list = get_endpoint_w_server_list(endpoint_id)

    if server_list == "S3":
        raise click.UsageError("You cannot delete servers from S3 endpoints.")

    # we don't *have to* raise an error in the GCP case, since the API would
    # deny it too, but doing so makes our errors a little bit more consistent
    # with deletes against S3 endpoints and shares
    if endpoint["is_globus_connect"]:
        raise click.UsageError(
            "You cannot delete servers from Globus Connect Personal endpoints"
        )

    if mode != "id":
        matches = _spec_to_matches(server_list, server, mode)
        if not matches:
            raise click.UsageError('No server was found matching "{}"'.format(server))
        elif len(matches) > 1:
            raise click.UsageError(
                dedent(
                    """\
                Multiple servers matched "{}":
                    {}
            """
                ).format(server, [x["id"] for x in matches])
            )
        else:
            server = matches[0]["id"]

    response = client.delete_endpoint_server(endpoint_id, server)

    formatted_print(response, text_format=FORMAT_TEXT_RAW, response_key="message")
639819
public DeleteAction delete(ByteBuffer... values) {
        return new DeleteAction(this, new LiteralOperand(
                new LinkedHashSet<ByteBuffer>(Arrays.asList(values))));
    }
1047626
public OperationFuture<List<Server>> shutDown(Group... groups) {
        return serverService().shutDown(
            getServerSearchCriteria(groups)
        );
    }
1060398
def _destroy_server(self, server_name):
        """"""
        try:
            del self.servers[server_name]
        except KeyError:
            pass

        if self.auto_close and not self.servers:
            loop.stop()
1145947
private static void deRegisterServer(Server server, Database db) {

        Iterator it = serverMap.values().iterator();

        for (; it.hasNext(); ) {
            HashSet databases = (HashSet) it.next();

            databases.remove(db);

            if (databases.isEmpty()) {
                it.remove();
            }
        }
    }
294877
public void delete(Set<HBeanRow> rows) {
        final List<Row> delete = new ArrayList<>();
        try {
            for (HBeanRow row : rows) {
                delete.add(new Delete(row.getRowKey()));
            }
            table.batch(delete);
            table.flushCommits();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }