def METHOD_NAME(self):
    """execution in one cycle"""
    now = datetime.datetime.utcnow()
    kickTime = now - datetime.timedelta(hours=self.KICK_GRACE_HOURS)
    rmTime = now - datetime.timedelta(days=self.DEL_GRACE_DAYS)
    # # kick
    statusList = ["Assigned"]
    requestIDsList = self.requestClient().getRequestIDsList(statusList, self.KICK_LIMIT)
    if not requestIDsList["OK"]:
        self.log.error(f"execute: {requestIDsList['Message']}")
        return requestIDsList
    requestIDsList = requestIDsList["Value"]
    kicked = 0
    for requestID, status, lastUpdate in requestIDsList:
        reqStatus = self.requestClient().getRequestStatus(requestID)
        if not reqStatus["OK"]:
            self.log.error(("execute: unable to get request status", reqStatus["Message"]))
            continue
        status = reqStatus["Value"]
        if lastUpdate < kickTime and status == "Assigned":
            getRequest = self.requestClient().peekRequest(requestID)
            if not getRequest["OK"]:
                self.log.error(f"execute: unable to read request '{requestID}': {getRequest['Message']}")
                continue
            getRequest = getRequest["Value"]
            if getRequest and getRequest.LastUpdate < kickTime:
                self.log.info(
                    "execute: kick assigned request (%s/'%s') in status %s"
                    % (requestID, getRequest.RequestName, getRequest.Status)
                )
                putRequest = self.requestClient().putRequest(getRequest)
                if not putRequest["OK"]:
                    self.log.error(
                        "execute: unable to put request (%s/'%s'): %s"
                        % (requestID, getRequest.RequestName, putRequest["Message"])
                    )
                    continue
                else:
                    self.log.verbose("Kicked request %d" % putRequest["Value"])
                kicked += 1
    # # delete
    statusList = ["Done", "Failed", "Canceled"] if self.DEL_FAILED else ["Done"]
    requestIDsList = self.requestClient().getRequestIDsList(statusList, self.DEL_LIMIT)
    if not requestIDsList["OK"]:
        self.log.error(f"execute: {requestIDsList['Message']}")
        return requestIDsList
    requestIDsList = requestIDsList["Value"]
    deleted = 0
    for requestID, status, lastUpdate in requestIDsList:
        if lastUpdate < rmTime:
            self.log.info(f"execute: deleting request '{requestID}' with status {status}")
            delRequest = self.requestClient().deleteRequest(requestID)
            if not delRequest["OK"]:
                self.log.error("execute: unable to delete request", f"'{requestID}': {delRequest['Message']}")
                continue
            deleted += 1
    # optional: Set Scheduled requests to Cancelled if older than threshold
    if self.cancelGraceDays > 0:
        cancelTime = datetime.datetime.utcnow() - datetime.timedelta(days=self.cancelGraceDays)
        result = self.requestClient().getRequestIDsList(["Scheduled"], self.DEL_LIMIT)
        if not result["OK"]:
            self.log.error("Failed to get list of Scheduled requests:", result["Message"])
            return result
        requestIDsList = result["Value"]
        cancelled = 0
        for requestID, status, lastUpdate in requestIDsList:
            if lastUpdate < cancelTime:
                self.log.info("Cancelling overdue request", str(requestID))
                cancelReq = self.requestClient().cancelRequest(requestID)
                if not cancelReq["OK"]:
                    self.log.error("Unable to cancel request", f"'{requestID}': {cancelReq['Message']}")
                    continue
                cancelled += 1
    self.log.info("execute: kicked assigned requests", str(kicked))
    self.log.info("execute: deleted finished requests", str(deleted))
    if self.cancelGraceDays > 0:
        self.log.info("execute: cancelled overdue requests", str(cancelled))
    return S_OK()