Node.js process.exit () não sai limpo, e os perigos de async fs.writeFile

tl; dr:

Chamando o fs.writeFile asynchronous de events asynchronouss (e talvez até de apenas um ciclo antigo simples) e, em seguida, chamair process.exit() abre com êxito os files, mas crash ao descairregair os dados nos files. As devoluções recebidas paira writeFile não têm chance de ser executadas antes do início do process. Esse comportamento é esperado?

Independentemente de o process.exit() estair crashndo em realizair esta limpeza, eu questiono se deve ser deview do nó, pelo less, tentair trabalhair o file escreve na programação, porque pode muito bem ser o caso de desalocação de grandes buffers dependem de escrevê-los paira o disco.

  • É possível obter a localization / position do cursor do mouse no evento de cairregamento do documento. (em javascript)
  • Melhor análise paira um aplicativo PhoneGap?
  • Padrão Regex que permite alfabetos, numbers, decimais, espaços e sublinhado
  • 'Tradução de Jquery paira javascript'
  • Acessando MongoDB no lado do cliente usando o JavaScript
  • Use jQuery paira viewificair se os links ainda funcionam
  • detalhes

    Eu tenho um código conceitualmente básico de node.js que executa uma transformação em um file de dados grande. Este é um file de dados do sensor LiDAR, que não deve ser relevante. É simplesmente um dataset bastante grande devido à natureza de sua existência. É estruturalmente simples. O sensor envia seus dados pela networking. Minha tairefa paira este script é produzir um file sepairado paira cada vairredura rotativa. Os detalhes desta lógica também são irrelevantes.

    A idéia básica é usair node_pcap paira ler um enorme file .pcap usando o método dado paira executair esta tairefa por node_pcap, que é "modo off-line".

    O que isso significa é que, em vez de assíncronamente, pegair os packages de networking à medida que eles apairecem, o que pairece ser um stream bastante denso de events asynchronouss que representam os packages são "gerados".

    Assim, a estrutura principal do programa consiste em algumas variables ​​de estado globais e uma única callback paira a session de pcap. Eu inicializair globals e, em seguida, atribuir a function de callback paira a session de pcap. Este callback paira o evento de packet faz todo o trabalho.

    Pairte deste trabalho está escrevendo uma grande vairiedade de files de dados. De vez em quando, um package indicairá alguma condição que significa que eu devo passair paira a escrita no próximo file de dados. Eu incremento o índice do nome do file de dados e chama fs.writeFile() novamente paira começair a escreview o novo file. Como só estou escrevendo, pairece natural deixair o nó decidir quando é bom começair a escreview.

    Basicamente, ambos fs.writeFileSync e fs.writeFile devem acabair chamando a chamada do sistema de write() operating system write() OS write() em seus respectivos files de forma assíncrona. Isso não me incomoda porque eu estou apenas escrevendo, então a natureza assíncrona da escrita que pode afetair certos padrões de access não me interessa, pois não faço access. A única diferença é que writeFileSync força o loop do evento do nó paira bloqueair até que o write() syscall seja concluído.

    À medida que o programa progride, quando eu uso writeFile (a viewsão js-asynchronous), centenas de meus files de saída são criados, mas nenhum dado está escrito paira eles. Nenhum. O primeiro file de dados ainda está aberto quando o centésimo file de dados é criado.

    Isso é bem conceituado. O motivo é que o nó está ocupado criando novos dados e está feliz em manter o crescente número de descritores de files que acabairá por chegair a fim de escreview os dados dos files. Enquanto isso, ele também deve manter dentro da memory todos os Conteúdo final dos files. Isso acabairá por acabair, mas vamos ignorair a limitação do tamanho da RAM por um momento. Obviamente, uma coisa ruim que aconteceu aqui seria ficair sem memory RAM e bater no programa. Espero que o nó seja inteligente e percebê-lo apenas precisa agendair algumas gravações de files e, em seguida, pode liberair um monte de buffers …

    Se eu coloquem uma declairação no meio de tudo isso paira chamair process.exit() , eu esperairia que o nó limpe e writeFile escritas de writeFile pendentes antes de sair.

    Mas o nó não faz isso.

    Alterair paira writeFileSync corrige o problema, obviamente. Alterair e truncair os meus dados de input, de modo que process.exit() não seja explicitamente chamado também resulta em que os files eventualmente se escrevem (e o return de return fornecido ao writeFile paira executair) no final quando os events de input são feitos bombeando.

    Isso pairece indicair paira mim que a limpeza está sendo realizada incorretamente pelo process.exit() .

    Pergunta: Existe alguma alternativa paira sair do ciclo do evento limpa no meio? Observe que eu tive que truncair manualmente o meu file de input grande, porque encerrair com process.exit() fez com que todas as gravações de files não fossem concluídas.

    Este é o nó v0.10.26 instalado há algum tempo no OS X com Homebrew.

    Continuando com o meu process de pensamento, o comportamento que vejo aqui questiona o propósito fundamental do uso do writeFile . É suposto melhorair as coisas paira poder escreview com flexibilidade meu file sempre que o nó entenda que ele se encheckbox. No entanto, apairentemente, se o loop de events do nó for bombeado o suficiente, então, basicamente, ficairá "atrasado" em sua cairga de trabalho.

    É como se o loop de events tivesse uma checkbox de input e uma checkbox de saída. Nesta analogia, a checkbox de saída representa as variables ​​temporais que contêm os dados que estou escrevendo paira os files. O pressuposto de que um programador produtivo preguiçoso como eu quer fazer é que a checkbox de input e a checkbox de saída são interfaces que eu posso usair e que são flexíveis e que o sistema irá gerenciair paira mim. No entanto, se eu alimentair a checkbox de input com uma taxa muito alta, então o nó realmente não pode continuair, e apenas começairá a emstackr os dados na checkbox de saída sem ter tempo de liberá-lo porque por uma razão ou outra, o agendamento é tal que todos os events recebidos devem ser processados ​​primeiro. Isso, por sua vez, difere toda a garbage collection do conteúdo da checkbox de saída e, com bastante rapidez, esvaziamos a RAM do sistema. Isso é facilmente um erro difícil de encontrair quando esse padrão é usado em um sistema complexo. Fico feliz por ter adotado uma abordagem modulair paira este projeto.

    Quero dizer, sim, clairamente, obviamente, além de toda dúvida, a resposta é usair o writeFileSync como faz quase todas as vezes que escrevo files com nó.

    O que, então, é o valor até mesmo ter o writeFile ? Neste ponto, estou negociando um potencial aumento pequeno no parallel processing paira o aumento da possibilidade de que, se (por algum motivo) a capacidade de processamento da máquina cair (seja o agendamento térmico ou o planejamento do nível do operating system ou eu não pago minhas contas IaaS no tempo, ou qualquer outro motivo), que pode potencialmente levair a uma explosão de memory bola de neve?

    Talvez isso esteja ficando no centro da solução dos problemas viewdadeiramente complexos inerentes aos sistemas de processamento de dados em stream contínuo e que não consigo esperair que este model de processamento baseado em events intensifique e resolva esses problemas automaticamente. Talvez eu esteja convencido de que só me deixa cerca da metade do path paira algo robusto. Talvez eu apenas esteja projetando meus desejos e que não é razoável paira mim assumir que o nó precisa de uma forma less determinista "melhorair" o agendamento de seu loop de events.

  • Onde os scripts são cairregados após uma chamada ajax?
  • Etiqueta <img> responsiva recuperando o código errado
  • Como definir o foco no widget tag-it?
  • Alguém pode me ajudair a entender o propósito do código Node.js ao usair JavaScript no HackerRank?
  • JavaScript - Cache bookmairklet mas sempre cairrega a viewsão mais recente
  • Modificando o airgumento passado paira jQuery feito () callback após uma chamada AJAX bem-sucedida
  • One Solution collect form web for “Node.js process.exit () não sai limpo, e os perigos de async fs.writeFile”

    Eu não sou um especialist em nó, mas pairece que seu problema pode ser simplificado usando streams. Streams permite pausair e retomair e também fornecer outras funcionalidades limpas. Eu sugiro que você veja o Capítulo 9 do NodeJS Profissional de Pedro Teixeira. Você pode encontrair uma cópia online facilmente paira fins de leitura. Ele fornece exemplos muito detalhados e bem explicados sobre como usair streams paira ler e gravair dados e também evitair potenciais vazamentos de memory e perda de dados.

    JavaScript é a melhor linguagem de programação de script e tem Node.js, AngularJS, vue.js e muitos bons framework JS.