ah-resque-ui/dist/actions/ah-resque-ui.js

A resque administration website for actionhero

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResqueRunDelayed = exports.ResqueDelDelayed = exports.ResqueDelayedJobs = exports.ResqueDelLock = exports.ResqueLocks = exports.ResqueRetryAndRemoveAllFailed = exports.ResqueRetryAndRemoveFailed = exports.ResqueRemoveAllFailed = exports.ResqueRemoveFailed = exports.ResqueResqueFailed = exports.ResqueDelQueue = exports.ResqueQueued = exports.ResqueFailedCount = exports.ResqueForceCleanWorker = exports.ResqueLoadWorkerQueues = exports.ResqueResqueDetails = exports.ResqueRedisInfo = void 0;
const os = require("os");
const actionhero_1 = require("actionhero");
// A helper class
class ResqueAction extends actionhero_1.Action {
    constructor() {
        super();
        this.middleware = ["ah-resque-ui-proxy-middleware"];
        this.logLevel = "debug";
        this.toDocument = false;
    }
}
class ResqueRedisInfo extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:redisInfo";
        this.description = "I return the results of redis info";
        this.inputs = {};
    }
    async run() {
        const redisInfo = await actionhero_1.api.resque.queue.connection.redis.info();
        if (redisInfo) {
            return { redisInfo: redisInfo.split(os.EOL) };
        }
    }
}
exports.ResqueRedisInfo = ResqueRedisInfo;
class ResqueResqueDetails extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:resqueDetails";
        this.description = "I return the results of api.tasks.details";
        this.inputs = {};
    }
    async run() {
        return { resqueDetails: await actionhero_1.task.details() };
    }
}
exports.ResqueResqueDetails = ResqueResqueDetails;
class ResqueLoadWorkerQueues extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:loadWorkerQueues";
        this.description = "I return the results of api.tasks.workers";
        this.inputs = {};
    }
    async run() {
        return { workerQueues: await actionhero_1.task.workers() };
    }
}
exports.ResqueLoadWorkerQueues = ResqueLoadWorkerQueues;
class ResqueForceCleanWorker extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:forceCleanWorker";
        this.description = "I remove a worker from resque";
        this.inputs = {
            workerName: { required: true },
        };
    }
    async run({ params }) {
        return {
            generatedErrorPayload: await actionhero_1.api.resque.queue.forceCleanWorker(params.workerName),
        };
    }
}
exports.ResqueForceCleanWorker = ResqueForceCleanWorker;
class ResqueFailedCount extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:resqueFailedCount";
        this.description = "I return a count of failed jobs";
        this.inputs = {};
    }
    async run() {
        return { failedCount: await actionhero_1.task.failedCount() };
    }
}
exports.ResqueFailedCount = ResqueFailedCount;
class ResqueQueued extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:queued";
        this.description = "I list enqueued jobs";
        this.inputs = {
            queue: {
                required: true,
            },
            start: {
                required: true,
                formatter: parseInt,
                default: 0,
            },
            stop: {
                required: true,
                formatter: parseInt,
                default: 99,
            },
        };
    }
    async run({ params }) {
        return {
            queueLength: await actionhero_1.api.resque.queue.length(params.queue),
            jobs: await actionhero_1.task.queued(params.queue, params.start, params.stop),
        };
    }
}
exports.ResqueQueued = ResqueQueued;
class ResqueDelQueue extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:delQueue";
        this.description = "I delete a queue";
        this.inputs = {
            queue: { required: true },
        };
    }
    async run({ params }) {
        return { deleted: await actionhero_1.task.delQueue(params.queue) };
    }
}
exports.ResqueDelQueue = ResqueDelQueue;
class ResqueResqueFailed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:resqueFailed";
        this.description = "I return failed jobs";
        this.inputs = {
            start: {
                required: true,
                formatter: parseInt,
                default: 0,
            },
            stop: {
                required: true,
                formatter: parseInt,
                default: 99,
            },
        };
    }
    async run({ params }) {
        return { failed: await actionhero_1.task.failed(params.start, params.stop) };
    }
}
exports.ResqueResqueFailed = ResqueResqueFailed;
class ResqueRemoveFailed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:removeFailed";
        this.description = "I remove a failed job";
        this.inputs = {
            id: {
                required: true,
                formatter: parseInt,
            },
        };
    }
    async run({ params }) {
        const failed = await actionhero_1.task.failed(params.id, params.id);
        if (!failed) {
            throw Error("failed job not found");
        }
        return { removed: await actionhero_1.task.removeFailed(failed[0]) };
    }
}
exports.ResqueRemoveFailed = ResqueRemoveFailed;
class ResqueRemoveAllFailed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:removeAllFailed";
        this.description = "I remove all failed jobs";
        this.inputs = {};
    }
    async run() {
        let removed = 0;
        const failed = await actionhero_1.task.failed(0, 0);
        if (failed && failed.length > 0) {
            const failedJob = failed[0];
            removed += await actionhero_1.task.removeFailed(failedJob);
            await this.run();
        }
        return { removed };
    }
}
exports.ResqueRemoveAllFailed = ResqueRemoveAllFailed;
class ResqueRetryAndRemoveFailed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:retryAndRemoveFailed";
        this.description = "I retry a failed job";
        this.inputs = {
            id: {
                required: true,
                formatter: parseInt,
            },
        };
    }
    async run({ params }) {
        const failed = await actionhero_1.task.failed(params.id, params.id);
        if (!failed) {
            throw new Error("failed job not found");
        }
        return { retried: actionhero_1.task.retryAndRemoveFailed(failed[0]) };
    }
}
exports.ResqueRetryAndRemoveFailed = ResqueRetryAndRemoveFailed;
class ResqueRetryAndRemoveAllFailed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:retryAndRemoveAllFailed";
        this.description = "I retry all failed jobs";
        this.inputs = {};
    }
    async run() {
        let retried = 0;
        const failed = await actionhero_1.task.failed(0, 0);
        if (failed && failed.length > 0) {
            const failedJob = failed[0];
            retried += (await actionhero_1.task.retryAndRemoveFailed(failedJob)) ? 1 : 0;
            await this.run();
        }
        return { retried };
    }
}
exports.ResqueRetryAndRemoveAllFailed = ResqueRetryAndRemoveAllFailed;
class ResqueLocks extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:locks";
        this.description = "I return all locks";
        this.inputs = {};
    }
    async run() {
        return { locks: await actionhero_1.task.locks() };
    }
}
exports.ResqueLocks = ResqueLocks;
class ResqueDelLock extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:delLock";
        this.description = "I delete a lock";
        this.inputs = {
            lock: { required: true },
        };
    }
    async run({ params }) {
        return { count: await actionhero_1.task.delLock(params.lock) };
    }
}
exports.ResqueDelLock = ResqueDelLock;
class ResqueDelayedJobs extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:delayedjobs";
        this.description = "I return paginated lists of delayedjobs";
        this.inputs = {
            start: {
                required: true,
                formatter: parseInt,
                default: 0,
            },
            stop: {
                required: true,
                formatter: parseInt,
                default: 99,
            },
        };
    }
    async run({ params }) {
        const timestamps = [];
        const delayedjobs = {};
        let timestampsCount = 0;
        const allTimestamps = await actionhero_1.task.timestamps();
        if (allTimestamps.length > 0) {
            timestampsCount = allTimestamps.length;
            for (let i = 0; i < allTimestamps.length; i++) {
                if (i >= params.start && i <= params.stop) {
                    timestamps.push(allTimestamps[i]);
                }
            }
            for (const j in timestamps) {
                const timestamp = timestamps[j];
                delayedjobs[timestamp] = await actionhero_1.task.delayedAt(timestamp);
            }
        }
        return { delayedjobs, timestampsCount };
    }
}
exports.ResqueDelayedJobs = ResqueDelayedJobs;
class ResqueDelDelayed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:delDelayed";
        this.description = "I delete a delayed job";
        this.inputs = {
            timestamp: {
                required: true,
                formatter: parseInt,
            },
            count: {
                required: true,
                formatter: parseInt,
            },
        };
    }
    async run({ params }) {
        const delayed = await actionhero_1.task.delayedAt(params.timestamp);
        if (delayed.tasks.length === 0 || !delayed.tasks[params.count]) {
            throw new Error("delayed job not found");
        }
        const job = delayed.tasks[params.count];
        return {
            timestamps: await actionhero_1.task.delDelayed(job.queue, job.class, job.args),
        };
    }
}
exports.ResqueDelDelayed = ResqueDelDelayed;
class ResqueRunDelayed extends ResqueAction {
    constructor() {
        super();
        this.name = "resque:runDelayed";
        this.description = "I run a delayed job now";
        this.inputs = {
            timestamp: {
                required: true,
                formatter: parseInt,
            },
            count: {
                required: true,
                formatter: parseInt,
            },
        };
    }
    async run({ params }) {
        const delayed = await actionhero_1.task.delayedAt(params.timestamp);
        if (delayed.tasks.length === 0 || !delayed.tasks[params.count]) {
            throw new Error("delayed job not found");
        }
        const job = delayed.tasks[params.count];
        await actionhero_1.task.delDelayed(job.queue, job.class, job.args);
        await actionhero_1.task.enqueue(job.class, job.args, job.queue);
    }
}
exports.ResqueRunDelayed = ResqueRunDelayed;