@grouparoo/core/dist/actions/resque.d.ts

The Grouparoo Core

import { ErrorPayload } from "node-resque";
import { AuthenticatedAction } from "../classes/actions/authenticatedAction";
import { ActionheroLogLevel, ParamsFrom } from "actionhero";
import { APIData } from "../modules/apiData";
import { ActionPermission } from "../models/Permission";
declare abstract class ResqueActionWrite extends AuthenticatedAction {
    permission: ActionPermission;
    logLevel: ActionheroLogLevel;
    toDocument: boolean;
    isWriteTransaction(): boolean;
    calculateResqueMetrics(): Promise<void>;
}
declare abstract class ResqueActionRead extends AuthenticatedAction {
    permission: ActionPermission;
    logLevel: ActionheroLogLevel;
    toDocument: boolean;
}
export declare class ResqueRedisInfo extends ResqueActionRead {
    name: string;
    description: string;
    runWithinTransaction(): Promise<{
        redisInfo: string[];
    }>;
}
export declare class ResqueResqueDetails extends ResqueActionRead {
    name: string;
    description: string;
    runWithinTransaction(): Promise<{
        resqueDetails: {
            queues: {
                [key: string]: any;
            };
            workers: {
                [key: string]: any;
            };
            stats: {
                [key: string]: any;
            };
            leader: string;
        };
        failedCount: number;
    }>;
}
export declare class ResqueLoadWorkerQueues extends ResqueActionRead {
    name: string;
    description: string;
    runWithinTransaction(): Promise<{
        workerQueues: {
            [key: string]: string;
        };
    }>;
}
export declare class ResqueForceCleanWorker extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly workerName: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueForceCleanWorker>;
    }): Promise<{
        generatedErrorPayload: ErrorPayload;
    }>;
}
export declare class ResqueFailedCount extends ResqueActionRead {
    name: string;
    description: string;
    runWithinTransaction(): Promise<{
        failedCount: number;
    }>;
}
export declare class ResqueQueued extends ResqueActionRead {
    name: string;
    description: string;
    inputs: {
        readonly queue: {
            readonly required: true;
        };
        readonly offset: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
            readonly default: 0;
        };
        readonly limit: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
            readonly default: 100;
        };
    };
    runWithinTransaction({ params }: {
        params: ParamsFrom<ResqueQueued>;
    }): Promise<{
        queueLength: number;
        jobs: import("actionhero/dist/classes/task").TaskInputs[];
    }>;
}
export declare class ResqueDelQueue extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly queue: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueDelQueue>;
    }): Promise<{
        deleted: void;
    }>;
}
export declare class ResqueResqueFailed extends ResqueActionRead {
    name: string;
    description: string;
    inputs: {
        readonly offset: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
            readonly default: 0;
        };
        readonly limit: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
            readonly default: 100;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueResqueFailed>;
    }): Promise<{
        total: number;
        failed: import("node-resque").ParsedFailedJobPayload[];
    }>;
}
export declare class ResqueRemoveFailed extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly id: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueRemoveFailed>;
    }): Promise<void>;
}
export declare class ResqueRemoveAllFailed extends ResqueActionWrite {
    name: string;
    description: string;
    runWithinTransaction(): Promise<void>;
}
export declare class ResqueRetryAndRemoveFailed extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly id: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueRetryAndRemoveFailed>;
    }): Promise<void>;
}
export declare class ResqueRetryAndRemoveAllFailed extends ResqueActionWrite {
    name: string;
    description: string;
    runWithinTransaction(): Promise<void>;
}
export declare class ResqueLocks extends ResqueActionRead {
    name: string;
    description: string;
    runWithinTransaction(): Promise<{
        locks: {
            [key: string]: string;
        };
    }>;
}
export declare class ResqueDelLock extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly lock: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueDelLock>;
    }): Promise<{
        count: number;
    }>;
}
export declare class ResqueDelayedJobs extends ResqueActionRead {
    name: string;
    description: string;
    inputs: {
        readonly offset: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
            readonly default: 0;
        };
        readonly limit: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
            readonly default: 100;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueDelayedJobs>;
    }): Promise<{
        delayedjobs: Record<number, any>;
        timestampsCount: number;
        total: number;
    }>;
}
export declare class ResqueDelDelayed extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly timestamp: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
        };
        readonly count: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueDelDelayed>;
    }): Promise<{
        timestamps: number[];
    }>;
}
export declare class ResqueRunDelayed extends ResqueActionWrite {
    name: string;
    description: string;
    inputs: {
        readonly timestamp: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
        };
        readonly count: {
            readonly required: true;
            readonly formatter: typeof APIData.ensureNumber;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<ResqueRunDelayed>;
    }): Promise<{
        success: boolean;
    }>;
}
export {};