node-cron | A simple cron-like job scheduler for Node.js | Cron Utils library

A couple things:

1. Scheduling */10 * * * * *, results in an exception. You'll simply need to remove that last comma.

2. Take a look at the node-cron code here in GitHub. More on this below.

When calling start() in a loop, you are essentially scheduling work to be done, then clearing that work to be scheduled in the next call, as the first line in start() clears any previous timers.

So, let's let node-cron do the scheduling 😃:

I have a same problem too, but i am using a serialport not epoll.

So, I think the cause of this problem is electron modules not the native module.

The reason your code isn't working is that mycronobj[item]schedulefunction is a string so is not invokable. You need to turn this string into a reference to the function with the same name.

The simplest solution to this is using eval, e.g:

SOLVED BY @chilkat Software by upgrading the current version of chilkat/ck-electron16-win64  and win32

You can use a Semaphore to prevent parallel calls.

You will need to know when purgeResponsesSurveys is done. So if it's asynchronous you will need to return Promise or receive a callback that will be called when purgeResponsesSurveys is done.

I used semaphore npm package. Here is a small example/simulation.

First, you need somewhere to save the name of the scheduled task, which defaults to a UUID V4 but can be provided as an option using the 3rd argument of the schedule method you are calling above.

With a reference to this name, either from a database or a constant that is hard-coded in the script you have wrote, you can use cron.getTasks to list all of the scheduled tasks to ensure that the current task doesn't already exist before scheduling it.

If you are referencing a hard-coded name, then calling the schedule method will replace the existing scheduled task, rather than creating a new task.

UPDATE

To set the name of the scheduled task, simply pass in an options object as a third argument to the schedule method you are calling, with a name for your task.

Example:

Nodejs runs your Javascript in a single thread unless you explicitly create a WorkerThread and run some code in that. True parallel execution where both jobs are running code that uses the CPU will only be accomplished if you either run each task in a WorkerThread or child process to get it out of the main thread.

Let me repeat, true parallel execution requires more than one thread or process in nodejs and nodejs does not do that by default so you will have to create a WorkerThread or child_process.

So, if you have code that takes more than a few ms to do its work and you want it to run at a fairly precise time, then you can't count on the main Javascript thread to do that because it might be busy at that precise time. Timers in Javascript will run your code no earlier than the scheduled time, and when that scheduled time comes around, the event loop is ready to run them, but they won't actually run until whatever was running before finishes and returns control back to the event loop so the event loop can run the code attached to your timer.

So, if all you're mostly doing is I/O kind of work (reading/writing files or network), then your actual Javascript execution time is probably only milliseconds and nodejs can be very, very responsive to run your timers pretty close to "on time". But, if you have computationally expensive things that keep the CPU busy for much longer, then you can't count on your timers to run "on time" if you run that CPU-heavy stuff in the main thread.

What you can do, is start up a WorkerThread, set the timer in the WorkerThread and run your code in the worker thread. As long as you don't ask that WorkerThread to run anything else, it should be ready to run that timer pretty much "on time".

Now WorkerThreads do share some resources with the main thread so they aren't 100% independent (though they are close to independent). If you want 100% independence, then you can start a nodejs child process that runs a node script, sets its own timers and runs its own work in that other process.

All that said, the single threaded model works very, very well at reasonably high scale for code that is predominantly I/O code because nodejs uses non-blocking I/O so while it's waiting to read or write from file or network, the main thread is free and available to run other things. So, it will often give the appearance of running things in parallel because progress is being made on multiple fronts. The I/O itself inside the nodejs library is either natively non-blocking (network I/O) or is happening in an OS-native thread (file I/O) and the programming interface to Javascript is callback or promise based so it is also non-blocking.

I mention all this because you don't say what your two operations that you want to run in parallel are (including your actual code allows us to write more complete answers). If they are I/O or even some crypto, then they may already be non-blocking and you may achieve desired parallelism without having to use additional threads or processes.

To resolve this issue update the "passport" lib version in your package.json: from "passport": "^0.5.2", to "passport": "^0.4.0", so it's same as used in @nestjs/passport@8.0.1.

I think it is your "0.0.0.0:5432".

If local, it should be just "localhost:5432". If deployed server is remote, it should be a certain IP address XXX.XXX.XXX.XXX:5432. If deployed server is home network, it should be "192.168.0.XXX:5432".

Check your postgres network configuration https://youtu.be/Erqp4C3Y3Ds