::
        
            DELETE /:login/machines/:id
        
        Initiate deletion of a stopped remote machine.
547007
def delete(self):
        
        j, r = self.datacenter.request('DELETE', self.path)
        r.raise_for_status()
1317953
def delete(self, id):
        
        try:
            response = yield self.client.delete(id)

            if response.get("n") > 0:
                self.write({"message": "Deleted %s object: %s" % (self.object_name, id) })
                return

            self.raise_error(404, "Resource not found")

        except InvalidId as ex:
            self.raise_error(400, message="Your ID is malformed: %s" % id)
        except:
            self.raise_error()

        self.finish()
163058
def delete(self, id):
        
        resp = self.client.accounts.delete(id)
        self.display(resp)
1287501
def delete(self, id):
        
        id = self.key_name(id)
        self.redis.delete(id)
373210
def delete(self):
        
        url = SyncList.key.format(clientId=self.clientIdentifier)
        url += '/' + str(self.id)
        self._server.query(url, self._server._session.delete)
817084
def delete(self):
        
        _, r = self.machine.datacenter.request('DELETE', self.path)
        r.raise_for_status()
436000
def delete(self):
        
        disks = self.get_disks()
        self.domain.undefine()
        for disk in disks:
            disk.wipe()
            disk.delete()
832132
def destroy(*args)
      # First remove all attachments
      medium_attachments.each do |ma|
        ma.destroy(*args)
      end

      # Finally, remove ourselves
      parent.with_open_session do |session|
        machine = session.machine
        machine.remove_storage_controller(name)
      end
    end
964650
def command_rm(self, system_id, *system_ids):
        
        # Intentionally reading the first system_id separately,
        # because it's required. The others are optional.
        # This ensures that we'll generate an error if someone tries to call
        # this without the required argument.
        system_ids = (system_id,) + system_ids
        has_failed = False
        for system_id in system_ids:
            try:
                system = SystemModel.create_by_id(system_id, self.environment)
                controller = SystemControllerModel(system, self.environment)
                controller.unmount()
                system.delete(self.environment)
            except SftpException as e:
                sys.stderr.write('Cannot remove %s: %s\n' % (system_id, str(e)))
                has_failed = True
        if has_failed:
            sys.exit(1)
1329883
def destroy(cls, *ids):
        
        for pk in ids:
            cls.find(pk).delete()
        cls.session.flush()
867447
def delete(self):
        """"""
        self.conn.delete(self.jid)
        self.reserved = False
259950
async def delete(self):
        
        if self.refresh_handle:
            self.refresh_handle.cancel()
            self.refresh_handle = None

        request = stun.Message(message_method=stun.Method.REFRESH,
                               message_class=stun.Class.REQUEST)
        request.attributes['LIFETIME'] = 0
        await self.request(request)

        logger.info('TURN allocation deleted %s', self.relayed_address)
        if self.receiver:
            self.receiver.connection_lost(None)
331773
def delete(self, id):
        
        self.conn.cursor().execute("DELETE FROM WeRoBot WHERE id=%s", (id, ))
        self.conn.commit()
875403
def destroy_rackspace(region, instance_id, access_key_id, secret_access_key):
    
    nova = connect_to_rackspace(region,
                                access_key_id,
                                secret_access_key)

    server = nova.servers.get(instance_id)
    log_yellow('deleting rackspace instance ...')
    server.delete()

    # wait for server to be deleted
    try:
        while True:
            server = nova.servers.get(server.id)
            log_yellow('waiting for deletion ...')
            sleep(5)
    except:
        pass
    log_green('The server has been deleted')
    os.unlink('data.json')
679829
def cleanup(self):
        
        if self.local_port is not None:
            logger.debug(("Stopping ssh tunnel {0}:{1}:{2} for "
                          "{3}@{4}".format(self.local_port,
                                           self.remote_address,
                                           self.remote_port,
                                           self.username,
                                           self.address)))
            if self.forward is not None:
                self.forward.stop()
                self.forward.join()
            if self.transport is not None:
                self.transport.close()
478845
def disconnect_handler(remote, *args, **kwargs):
    """"""
    if not current_user.is_authenticated:
        return current_app.login_manager.unauthorized()

    account = RemoteAccount.get(user_id=current_user.get_id(),
                                client_id=remote.consumer_key)
    external_id = account.extra_data.get('external_id')

    if external_id:
        oauth_unlink_external_id(dict(id=external_id, method='cern'))
    if account:
        with db.session.begin_nested():
            account.delete()

    disconnect_identity(g.identity)

    return redirect(url_for('invenio_oauthclient_settings.index'))
330923
def remove_state_machine(self, state_machine_id):
        
        import rafcon.core.singleton as core_singletons
        removed_state_machine = None
        if state_machine_id in self._state_machines:
            logger.debug("Remove state machine with id {0}".format(state_machine_id))
            removed_state_machine = self._state_machines.pop(state_machine_id)
        else:
            logger.error("There is no state_machine with state_machine_id: %s" % state_machine_id)
            return removed_state_machine

        # destroy execution history
        removed_state_machine.destroy_execution_histories()
        return removed_state_machine