Delete the published wsdl
168882
public void unpublishWsdlFiles() throws IOException
   {
      String deploymentDir = (dep.getParent() != null ? dep.getParent().getSimpleName() : dep.getSimpleName());

      File serviceDir = new File(serverConfig.getServerDataDir().getCanonicalPath() + "/wsdl/" + deploymentDir);
      deleteWsdlPublishDirectory(serviceDir);
   }
1099667
def delete_raw(self):
        
        return client.delete(
            self.path(which='self'),
            **self._server_config.get_client_kwargs()
        )
686104
def delete_sp_template_for_vlan(self, vlan_id):
        """"""
        with self.session.begin(subtransactions=True):
            try:
                self.session.query(
                    ucsm_model.ServiceProfileTemplate).filter_by(
                    vlan_id=vlan_id).delete()
            except orm.exc.NoResultFound:
                return
968582
def clean(self):
        
        to_del = []
        for serv in self:
            if not serv.host:
                to_del.append(serv.uuid)
        for service_uuid in to_del:
            del self.items[service_uuid]
854180
async function erase(ws) {
    await unlink(ws.path)
    if (ws.writable) {
        await endStream(ws)
    }
    return ws
}
1258662
def tablespace_remove(name, user=None, host=None, port=None,
                      maintenance_db=None, password=None, runas=None):
    '''
    
    '''
    query = 'DROP TABLESPACE "{0}"'.format(name)
    ret = _psql_prepare_and_run(['-c', query],
                                user=user,
                                host=host,
                                port=port,
                                runas=runas,
                                maintenance_db=maintenance_db,
                                password=password)
    return ret['retcode'] == 0
1264932
def destroy(self):
        

        if getattr(self, 'publisher', None):
            self.log.debug("closing fedmsg publisher")
            self.log.debug("sent %i messages" % self._i)
            self.publisher.close()
            self.publisher = None

        if getattr(self, 'context', None):
            self.context.term()
            self.context = None
757538
public static function cleanup()
    {
        remove_action('wp_head', 'feed_links_extra', 3); // remove extra RSS links (as category)
        remove_action('wp_head', 'rsd_link');
        remove_action('wp_head', 'wlwmanifest_link');
        remove_action('wp_head', 'adjacent_posts_rel_link_wp_head', 10, 0);
        remove_action('wp_head', 'wp_shortlink_wp_head', 10, 0);
        remove_filter('dbem_notes', 'wpautop');

        global $wp_widget_factory;
        remove_action('wp_head', [$wp_widget_factory->widgets['WP_Widget_Recent_Comments'], 'recent_comments_style']);
    }
1313887
def deleteOTPK(self, otpk_pub):
        

        self.__checkSPKTimestamp()

        for otpk in self.__otpks:
            if otpk.pub == otpk_pub:
                self.__otpks.remove(otpk)

        for otpk in self.__hidden_otpks:
            if otpk.pub == otpk_pub:
                self.__hidden_otpks.remove(otpk)

        self.__refillOTPKs()
431265
def remove(self, func):
        """"""
        if not self.data['name'].startswith(self.prefix):
            return
        parent = self.get_parent(self.get_log())
        _, sink_path, _ = self.get_sink()
        client = self.session.client(
            'logging', 'v2', '%s.sinks' % (parent.split('/', 1)[0]))
        try:
            client.execute_command(
                'delete', {'sinkName': sink_path})
        except HttpError as e:
            if e.resp.status != 404:
                raise
1011276
function() {
    Object.keys(this.name2Ws).forEach(function(name) {
      delete this.name2Ws[name];
    }.bind(this));

    Object.keys(this.ws2Name).forEach(function(wsId) {
      delete this.ws2Name[wsId];
    }.bind(this));
  }
1227849
private void cleanupEndpointActivationServiceInfo(EndpointActivationServiceInfo easInfo) {
        if (easInfo.serviceRef == null && easInfo.endpointFactories.isEmpty()) {
            endpointActivationServices.remove(easInfo.id);
        }
    }
349561
private void cleanupAdminObjectServiceInfo(NamedAdminObjectServiceInfo aosInfo) {
        if (aosInfo.serviceRef == null && aosInfo.endpointFactories.isEmpty()) {
            endpointActivationServices.remove(aosInfo.id);
        }
    }
326568
def deleteWebhook(self, hook_id):
        """"""
        path = '/'.join(['notification', 'webhook', hook_id])
        return self.rachio.delete(path)
532249
def cleanup_deployments(self):
        
        deployments = self.list_deployments()

        for deployment in deployments:
            if deployment.namespace in self.managed_namespaces:
                deployment.delete()
1114272
def delete(self):
        
        self.manager.session.delete(self.uri)
        self.manager._metrics_contexts.remove(self)
1080741
def cleanup(self):
        """"""
        self.parser = None
        self.request = None
        self.url = None
        self.headers = None
        self._request_handler_task = None
        self._request_stream_task = None
        self._total_request_size = 0
        self._is_stream_handler = False