¿Cómo evitar que termine un proceso Node.js?

edge.js

Question

TL; DR

¿Cuál es la mejor manera de mantener a la fuerza un proceso Node.js en ejecución, es decir, evitar que el bucle de eventos se ejecute vacío y, por lo tanto, evitar que el proceso finalice? La mejor solución que pude encontrar fue esta:

const SOME_HUGE_INTERVAL = 1 << 30;
setInterval(() => {}, SOME_HUGE_INTERVAL);

Lo que mantendrá un intervalo en ejecución sin causar demasiada perturbación si mantiene el período de intervalo lo suficientemente largo.

Hay una mejor manera de hacerlo?

Versión larga de la pregunta.

Tengo una secuencia de comandos Node.js que utiliza Edge.js para registrar una función de devolución de llamada para que pueda llamarse desde una DLL en .NET. Esta función se llamará 1 vez por segundo, enviando un número de secuencia simple que debe imprimirse en la consola.

La parte de Edge.js está bien, todo está funcionando. Mi único problema es que mi proceso Node.js ejecuta su script y después de eso se queda sin eventos para procesar. Con su bucle de eventos vacío, simplemente termina, ignorando el hecho de que debería haberse seguido ejecutando para poder recibir devoluciones de llamada desde la DLL.

Mi script Node.js:

var
    edge = require(''edge'');

var foo = edge.func({
    assemblyFile: ''cs.dll'',
    typeName: ''cs.MyClass'',
    methodName: ''Foo''
});

// The callback function that will be called from C# code:
function callback(sequence) {
    console.info(''Sequence:'', sequence);
}

// Register for a callback:
foo({ callback: callback }, true);

// My hack to keep the process alive:
setInterval(function() {}, 60000);

Mi código C # (la DLL):

public class MyClass
{
    Func<object, Task<object>> Callback;

    void Bar()
    {
        int sequence = 1;

        while (true)
        {
            Callback(sequence++);
            Thread.Sleep(1000);
        }
    }

    public async Task<object> Foo(dynamic input)
    {
        // Receives the callback function that will be used:
        Callback = (Func<object, Task<object>>)input.callback;

        // Starts a new thread that will call back periodically:
        (new Thread(Bar)).Start();

        return new object { };
    }
}

La única solución que se me ocurrió fue registrar un temporizador con un largo intervalo para llamar a una función vacía solo para mantener el programador ocupado y evitar que el ciclo de eventos se quede vacío para que el proceso siga funcionando para siempre.

¿Hay alguna manera de hacer esto mejor que yo? Es decir, mantener el proceso en ejecución sin tener que usar este tipo de "hack"?

Answer 1

Aunque parece que no hay una respuesta correcta a esta pregunta, hasta ahora tenemos 3 posibles hacks y honestamente creo que mi enfoque es el menos intrusivo:

setInterval(() => {}, 1 << 30);

Esto establecerá un intervalo que se activará aproximadamente una vez cada 12 días.

Originalmente, mi hack pasó Number.POSITIVE_INFINITY como el período, por lo que el temporizador nunca se Number.POSITIVE_INFINITY , pero este comportamiento se cambió recientemente y ahora la API no acepta nada mayor que 2147483647 (es decir, 2 ** 31 - 1 ). Vea los documentos here y here .

Para referencia, aquí están las otras dos respuestas dadas hasta ahora:

Joe''s:

require(''net'').createServer().listen();

Creará un "oyente falso", como él lo llamó. Un pequeño inconveniente es que asignamos un puerto solo para eso.

De Jacob:

process.stdin.resume();

O el equivalente:

process.stdin.on("data", () => {});

Pone a stdin en modo "antiguo", una característica obsoleta que todavía está presente en Node.js por compatibilidad con scripts escritos antes de Node.js v0.10 ( reference ).

Answer 2

Use el modo de transmisión "antiguo" para escuchar una entrada estándar que nunca llegará:

// Start reading from stdin so we don''t exit.
process.stdin.resume();