Deletes the given server.

@param server the server to be deleted.
@throws FlexiantException
188949
public void deleteServer(final de.uniulm.omi.cloudiator.flexiant.client.domain.Server server)
        throws FlexiantException {
        this.deleteServer(server.getId());
    }
855060
public void delete(String key) throws EtcdClientException {
        Preconditions.checkNotNull(key);

        URI uri = buildUriWithKeyAndParams(key, null);
        HttpDelete delete = new HttpDelete(uri);

        syncExecute(delete, new int[]{200, 404});
    }
699226
public static void unregisterMbean(MBeanServer server, ObjectName name) {
        try {
            server.unregisterMBean(name);
        } catch(Exception e) {
            logger.error("Error unregistering mbean", e);
        }
    }
164198
public static void unpopulateMBeanServer() {
		if(!populated)
			return;
		
		synchronized (lock) {
			populated = false;
			
			if (storageManager != null && storageManager.getPublicName() != null) {
				logger.info("Unregistering the StorageManager MXBean");
				try { 
					storageManager.deregister(); 
					storageManager.awaitJobTermination(2 * 60);
				} catch(Exception ex) {
					logger.warn("Can't unregister StorageManager MXBean.", ex);
				}
			}
			if (serverMonitor != null && serverMonitor.getPublicName() != null) {
				logger.info("Unregistering the ServerMonitor MXBean");
				try { 
					serverMonitor.deregister(); 
					serverMonitor.shutdown();
				} catch(Exception ex) {
					logger.warn("Can't unregister ServerMonitor MXBean.", ex);
				}
			}
			
			storageManager = null;
			serverMonitor = null;
		}
	}
568798
public function delete($id)
    {
        $this->_write(sprintf('delete %d', $id));
        $status = $this->_read();

        switch ($status) {
            case 'DELETED':
                return true;
            case 'NOT_FOUND':
                return false;
            default:
                throw new ServerException('Delete error: '.$status);
        }
    }
340756
function closeServer(done) {
            if (self.server) {
                self.server.close();
                self.server.removeListener('error', handlers.relayError);
            }
            self.httpServer.close(done);
        }
1274662
@Override
    public void deleteServerLease(String recoveryIdentity) throws Exception {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "deleteServerLease", new java.lang.Object[] { recoveryIdentity, this });

        Connection conn = null;
        boolean sqlSuccess = false;
        SQLException currentSqlEx = null;

        Statement deleteStmt = null;

        try
        {
            // Have we acquired the reference to the DataSource yet?
            if (_theDS == null)
            {
                _theDS = getDataSourceFromProperties();
                // We've looked up the DS, so now we can get a JDBC connection
                if (_theDS != null)
                {
                    conn = getConnection(_theDS);
                }
            }
            else
            {
                // Try and get a new connection
                conn = _theDS.getConnection();
            }

            // If we were unable to get a connection, throw an exception
            if (conn == null)
            {
                if (tc.isEntryEnabled())
                    Tr.exit(tc, "deleteServerLease", "Null connection InternalLogException");
                throw new InternalLogException("Failed to get JDBC Connection", null);
            }

            if (tc.isDebugEnabled())
                Tr.debug(tc, "Set autocommit FALSE on the connection");
            conn.setAutoCommit(false);

            // We can go ahead and write to the Database
            deleteStmt = conn.createStatement();

            String deleteString = "DELETE FROM " + _leaseTableName +
                                  " WHERE SERVER_IDENTITY='" + recoveryIdentity + "'";
            if (tc.isDebugEnabled())
                Tr.debug(tc, "delete server lease for " + recoveryIdentity + "using string " + deleteString);

            int ret = deleteStmt.executeUpdate(deleteString);

            if (tc.isDebugEnabled())
                Tr.debug(tc, "Have deleted row with return: " + ret + ", commit the change");

            conn.commit();
            Tr.audit(tc, "WTRN0108I: Deleted Lease for server with recovery identity " + recoveryIdentity);
        }
        // Catch and report an SQLException. In the finally block we'll determine whether the condition is transient or not.
        catch (SQLException sqlex)
        {
            if (tc.isDebugEnabled())
                Tr.debug(tc, "Lease delete failed with exception: " + sqlex);
        } finally
        {

            if (deleteStmt != null && !deleteStmt.isClosed())
                deleteStmt.close();
            if (conn != null)
                conn.close();
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "deleteServerLease");
    }
266671
function destroyServer(server, topology, callback) {
  LOCAL_SERVER_EVENTS.forEach(event => server.removeAllListeners(event));

  server.destroy(() => {
    topology.emit(
      'serverClosed',
      new monitoring.ServerClosedEvent(topology.s.id, server.description.address)
    );

    if (typeof callback === 'function') callback(null, null);
  });
}
595461
private void dispatchServerChannelDeleteEvent(ServerChannel channel) {
        ServerChannelDeleteEvent event = new ServerChannelDeleteEventImpl(channel);

        api.getEventDispatcher().dispatchServerChannelDeleteEvent(
                (DispatchQueueSelector) channel.getServer(), channel.getServer(), channel, event);
    }
1272443
@Override
    public void destroy() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Destroy " + getExternalName());
        }
        // Destroy the server socket
        if (this.endPoint != null) {
            this.endPoint.destroyServerSocket();
        }
        // disconnect from the factory
        if (null != this.channelFactory) {
            this.channelFactory.removeChannel(this.channelName);
        }
    }
916737
public function delete()
    {     
        Util::delTree( $this->getPath() );
        foreach (Server::enum() as $s) {
            $tname = str_replace( THEME_DIR.'/', '', $s->templateDir );
            if ($tname == $this->name) {
                $s->setTheme();
            }
        }
    }
48003
public void removeServerSocket(
      InternalInstrumented<ServerStats> server, InternalInstrumented<SocketStats> socket) {
    ServerSocketMap socketsOfServer = perServerSockets.get(id(server));
    assert socketsOfServer != null;
    remove(socketsOfServer, socket);
  }
1363823
public OperationFuture<Server> removeAutoscalePolicyOnServer(Server server) {
        autoscalePolicyClient
            .removeAutoscalePolicyOnServer(
                serverService.findByRef(server).getId()
            );

        return new OperationFuture<>(server, new NoWaitingJobFuture());
    }
728063
@Override
	public void delete() throws JMSException
    {
        if (connection == null)
            throw new FFMQException("Temporary queue already deleted","QUEUE_DOES_NOT_EXIST");
            
        connection.deleteTemporaryQueue(name);
        connection = null;
    }
352590
public function dodeleteAction()
  {
    $this->setNoRender();

    /* grab user parameters from $_REQUEST array */
    $sid = TeamSpeak3_Helper_Uri::getUserParam("id", 0);

    try
    {
      /* check if deleted server was selected */
      if($this->ts3->serverSelectedId() == $sid)
      {
        /* deselect server */
        $this->ts3->serverDeselect();
      }

      /* delete server */
      $this->ts3->serverDelete($sid);

      /* update session variables */
      $_SESSION["_serverqry"] = serialize($this->ts3);

      /* save custom ok mesage */
      $this->setLastEvent("The virtual server (ID " . $sid . ") has been deleted.");
    }
    catch(Exception $e)
    {
      /* save catched error mesage */
      $this->setLastEvent($e->getMessage(), TRUE);
    }

    /* goto indexAction() */
    $this->redirect("server");
  }
248221
@Override
    public void delete() {
        final FedoraResource description = getDescription();

        if (description != null) {
            description.delete();
        }

        super.delete();
    }
202083
@Override
    public String delete(EntityDeleteOperation deleter) throws ServiceException {
        try {
            return service.delete(deleter);
        } catch (UniformInterfaceException e) {
            throw processCatch(new ServiceException(e));
        } catch (ClientHandlerException e) {
            throw processCatch(new ServiceException(e));
        }
    }