Send DELETE message to an endpoint.
		
		:param str ep: name of endpoint
		:param fnptr cbfn: Optional - callback funtion to call when operation is completed
		:return: successful ``.status_code`` / ``.is_done``. Check the ``.error``
		:rtype: asyncResult
498210
def deleteEndpoint(self,ep,cbfn=""):
		'''
		
		'''
		result = asyncResult(callback=cbfn)
		result.endpoint = ep
		data = self._deleteURL("/endpoints/"+ep)
		if data.status_code == 200: #immediate success
			result.error = False
			result.is_done = True
		elif data.status_code == 202:
			self.database['async-responses'][json.loads(data.content)["async-response-id"]]= result
		else:
			result.error = response_codes("resource",data.status_code)
			result.is_done = True
		result.raw_data = data.content
		result.status_code = data.status_code
		return result
934031
public Response delete(String endpoint) {
        return call(Method.DELETE, endpoint, null, null);
    }
225347
def remote_complete(self, failure=None):
        
        self.worker.messageReceivedFromWorker()
        # call the real remoteComplete a moment later, but first return an
        # acknowledgement so the worker can retire the completion message.
        if self.active:
            eventually(self._finished, failure)
        return None
74746
def finish!
      if hixie_75? or hixie_76?
        send_data "\xff\x00"
      else
        send_frame OPCODE_CLOSE
      end

      EM.next_tick { callback(:on_finish, self) rescue error! "Error in finish callback" }
      EM.next_tick { close_connection_after_writing }

      @state = :finished
    rescue
      error! "Error finishing WebSocket connection"
    end
259570
def endpoint_delete(service, region=None, profile=None, interface=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    endpoint = endpoint_get(service, region, profile, interface, **connection_args)
    if not endpoint or 'Error' in endpoint:
        return {'Error': 'Could not find any endpoints for the service'}
    kstone.endpoints.delete(endpoint['id'])
    endpoint = endpoint_get(service, region, profile, interface, **connection_args)
    if not endpoint or 'Error' in endpoint:
        return True
744633
def connect(endpoint)
      rc = ffi_delegate.connect("%s", :string, endpoint)
      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
    end
784136
def call(self, method, params):
        
        msgid = self._endpoint.send_request(method, params)
        while True:
            if not self._endpoint.receive_messages():
                raise EOFError("EOF")
            res = self._endpoint.get_response(msgid)
            if res:
                result, error = res
                if error is None:
                    return result
                raise RPCError(error)
            self._process_input_notification()
            self._process_input_request()
1308455
def delete(self, endpoint: str, **kwargs) -> dict:
        """"""

        return self._request('DELETE', endpoint, **kwargs)
290540
def send(self, endpoint, json_message):
        
        _send_event_task.spool(endpoint=endpoint, json_message=json_message)
1126966
def delete_message(self, message, callback=None):
        
        return self.connection.delete_message(self, message, callback=callback)
943526
def bookmark_list():
    
    client = get_client()

    bookmark_iterator = client.bookmark_list()

    def get_ep_name(item):
        ep_id = item["endpoint_id"]
        try:
            ep_doc = client.get_endpoint(ep_id)
            return display_name_or_cname(ep_doc)
        except TransferAPIError as err:
            if err.code == "EndpointDeleted":
                return "[DELETED ENDPOINT]"
            else:
                raise err

    formatted_print(
        bookmark_iterator,
        fields=[
            ("Name", "name"),
            ("Bookmark ID", "id"),
            ("Endpoint ID", "endpoint_id"),
            ("Endpoint Name", get_ep_name),
            ("Path", "path"),
        ],
        response_key="DATA",
        json_converter=iterable_response_to_dict,
    )
112358
def delete(self, endpoint, **kwargs):
        
        kwargs.update(self.kwargs.copy())
        response = requests.delete(self.make_url(endpoint), **kwargs)
        return _decode_response(response)
1235409
def bind(endpoint)
      rc = ffi_delegate.bind("%s", :string, endpoint)
      raise_zmq_err("unable to bind to %p" % endpoint) if rc == -1
      @last_tcp_port = rc if rc > 0
    end
511054
def delete_endpoint(endpoint_id)
      endpoint = EndPoint.new({:id => endpoint_id}, @client)
      endpoint.domain_id = id
      endpoint.delete()
    end
677040
def delete_endpoint(self, endpoint_name):
        
        LOGGER.info('Deleting endpoint with name: {}'.format(endpoint_name))
        self.sagemaker_client.delete_endpoint(EndpointName=endpoint_name)
494931
def on_close(self):
        '''
        
        '''

        if self.id in self.funcserver.websocks:
            self.funcserver.websocks[self.id] = None
            ioloop = tornado.ioloop.IOLoop.instance()
            ioloop.add_callback(lambda: self.funcserver.websocks.pop(self.id, None))

        psession = self.funcserver.pysessions.get(self.pysession_id, None)
        if psession:
            psession['socks'].remove(self.id)
            if not psession['socks']:
                del self.funcserver.pysessions[self.pysession_id]
719812
def transferReporter(self, xferId, message):
        ''' 
        '''
        if self.is_stopped():
            return True

        _asp_message = AsperaMessage(message)

        if not _asp_message.is_msg_type(
            [enumAsperaMsgType.INIT,
             enumAsperaMsgType.DONE,
             enumAsperaMsgType.ERROR,
             enumAsperaMsgType.FILEERROR,
             enumAsperaMsgType.STATS]):
                return

        _session_id = _asp_message.get_session_id()

        _msg = self.debug_id(xferId, _session_id) + " : " + _asp_message._msg_type
        logger.info(_msg)

        with self._session_lock:
            if _asp_message.is_msg_type([enumAsperaMsgType.INIT]):
                assert(_session_id not in self._sessions)
                _session = AsperaSession(_session_id)
                self._sessions[_session_id] = _session
                self.notify_init()
            else:
                _session = self._sessions[_session_id]

        if _asp_message.is_msg_type([enumAsperaMsgType.DONE]):
            if _session.set_bytes_transferred(_asp_message.get_bytes_transferred()):
                self.notify_progress()
            _session.set_success()
            self.notify_done()
        elif _asp_message.is_msg_type([enumAsperaMsgType.ERROR, enumAsperaMsgType.FILEERROR]):
            _session.set_error(_asp_message.get_error_descr())
            self.notify_done(error=True)
        elif _asp_message.is_msg_type([enumAsperaMsgType.STATS]):
            if _session.set_bytes_transferred(_asp_message.get_bytes_transferred()):
                self.notify_progress()