Is there any delay function

BLOMASKY

I have to call a REST API from Aware for a bunch of records. The stupid API gets upset if I make too many calls / second. Is there anyway to put a delay (preferably about 500ms but would settle for 1 second) in a procedure in aware?

Thanks
Bruce

BobK

I have the exact same issue.

I have NOT gotten the following to work, but this is the direction I was going in.

I found the following javascript on the internet and is suppose to sleep for 2 seconds.

// 1. Define the helper
const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function main() {
//    console.log("Start");
    
    // 2. Wait for 2 seconds
    await sleep(2000); 
    
//    console.log("Finish after 2 seconds");
}

main();

Then in AwareIM I use
EXEC_SCRIPT to execute the javascript.

In my first (and only test) AwareIM could not find the javascript, so I assume I have it in the wrong place.

I have too busy to try to debug this.

Any suggestions on the above or a better solution and I am all ears.

FYI: my javascript knowledge is almost non-existent.

nhofkes

The javascript code is in itself correct, and you can include it direcly in the EXEC_SCRIPT function. For example:
EXEC_SCRIPT 'async function main() {await new Promise(resolve => setTimeout(resolve, 2000));} main();'
(I shortened the code a bit, at the expense of readability).

However, I tested this and it does not work. This is because AwareIM executes the code asynchronously, in other words it starts the execution of the javascript code on the client but doesn’t wait for the script to finish (after the 2 second delay). So it does not actually delay the server (apart from the short time that it takes to send the javascript call to the client).

In principle it would be technically possible to have a java function (not javascript) executed on the server, but this is rather complicated so I wouldn’t recommend that.

A better approach is probably to use the scheduling function. The scheduler can call a process at regular intervals, which process calls the REST API for only a limited number of records and then terminates, and continues at the next call by the scheduler. You need to implement a counter that keeps track of the records that are being processed (which I think could be stored in the session object, haven’t tested that). The big advantage of this approach is that it doesn’t freeze the server, it remains responsive and available to do other stuff while the API calls are being made in the background. In the case that the REST API calls are being started by a user, it’s probably useful to have the process send a notification after all records have been processed, to inform the user.

BobK

Thank you nhofkes for saving me the time trying to get that javascript to work.

What is the name of the folder, in the ‘Custom’ folder, that could hold custom javascrip?
Just for future refence.

BLOMASKY

nhofkes In my case, I am calling a REST process to send statements to 100’s of customers. This happens once a month when the customer triggers the statement process. Not sure how I could use this with a scheduler since it it not on any particular day / time. I am just thinking out loud now, but I wonder if instead of an EXEC_SCRIPT call, I call a stored procedure that has a built in delay. so my 2 line process would look like:
EXEC_SP ‘MyDelayFunction’
REQUEST SERVICE emailStatements of MyRest

Bruce

BLOMASKY

And it works fine. I am using MSSQL so not sure if other databases have a “waitfor” function. But in Aware, I call the SP and pass the # of seconds and ms to wait in a string like SS.MMM. So my call in Aware looks like:

EXEC_SP ‘DelayMs’ WITH ‘@DelayMs’ = ’02.500

The SQL Server SP looks like:
CREATE PROCEDURE dbo.DelayMs
@DelayMs char(6)
– Expect input as SS.MMM
AS
BEGIN
DECLARE @DelayTime char(12) = ‘00:00:’ + @DelayMs
WAITFOR DELAY @DelayTime;
END;

Life is good.

nhofkes

BLOMASKY Not sure how I could use this with a scheduler since it it not on any particular day / time

You write that the customer triggers the statement process. You could separate that in two steps: the customer does not start the actual REST process, but only a (short) process that sets some flag indicating that the process must be started. The scheduler process can then regularly check (say every 10 minutes, depending on the customer’s needs) whether the flag is set, in other words, whether the customer initiated the monthly statements. If so, the process then sends the statements with the same intervals.

Of course, this would imply regular checking whether the customer already started the process, and most often nothing changed. However, because only a simple flag needs to be checked the overhead is probably neglible and in my view preferable over forced delays as that will impact both the server and potentially also other applications that use the same database server.

As an alternative approach:
Perhaps it’s possible to create a loop function, maybe through a special purpose BO and the ‘While’ functionality, that processes the statements only every few seconds. The loop process can check the current time and send out one statement every 2 seconds. The remainder of the time it is just spinning. This should of course be implemented as a background process, but you may have done that already.

customaware

I use this Stored Procedure (Maria DB)

– Name: delay_seconds(n)
– Purpose: Delay Procedure for Aware to execute an n second delay
– Called: EXEC_SP ‘delay_seconds’ WITH ‘p_seconds’= 2
– Created: 20240605
– Created By: Customaware Systems

DELIMITER //
CREATE OR REPLACE PROCEDURE delay_seconds(
IN p_seconds INT
)
BEGIN
– Safety check: prevent extremely long or negative sleeps
IF p_seconds IS NULL THEN
SET p_seconds = 0;
ELSEIF p_seconds < 0 THEN
SET p_seconds = 0;
ELSEIF p_seconds > 3600 THEN – optional: limit to 1 hour max
SIGNAL SQLSTATE ‘45000’
SET MESSAGE_TEXT = ‘Sleep duration cannot exceed 3600 seconds (1 hour)’;
END IF;

-- Perform the sleep and return the result (SLEEP() returns 0 on success, 1 if interrupted)
SELECT SLEEP(p_seconds) AS sleep_result;

END//
DELIMITER ;

Call it in Aware as follows….

EXEC_SP ‘delay_seconds’ WITH ‘p_seconds’= 2