kue
v0.11.6
Por favor, veja, por exemplo, Bull como uma alternativa. Obrigado!
Kue é uma fila de emprego prioritária apoiada pela Redis, construída para Node.JS.
Protip Esta é a mais recente documentação do Kue, também leia o Changelist.
Última lançamento:
$ npm install kue
Ramo Master:
$ npm install http://github.com/Automattic/kue/tarball/master
Primeiro, crie uma Queue de emprego com kue.createQueue() :
var kue = require ( 'kue' )
, queue = kue . createQueue ( ) ; Chamando queue.create() com o tipo de trabalho ("email") e dados de trabalho arbitrários retornarão um Job , que poderá ser save() ed, adicionando -o ao redis, com um nível de prioridade padrão de "Normal". O método save() aceita opcionalmente um retorno de chamada, respondendo com um error se algo der errado. A chave title é especial e será exibida nas listagens de empregos na interface do usuário, facilitando a localização de um trabalho específico.
var job = queue . create ( 'email' , {
title : 'welcome email for tj'
, to : '[email protected]'
, template : 'welcome-email'
} ) . save ( function ( err ) {
if ( ! err ) console . log ( job . id ) ;
} ) ; Para especificar a prioridade de um trabalho, basta invocar o método priority() com um número ou nome de prioridade, que é mapeado para um número.
queue . create ( 'email' , {
title : 'welcome email for tj'
, to : '[email protected]'
, template : 'welcome-email'
} ) . priority ( 'high' ) . save ( ) ;O mapa de prioridade padrão é o seguinte:
{
low : 10
, normal : 0
, medium : - 5
, high : - 10
, critical : - 15
} ; Por padrão, os trabalhos têm apenas uma tentativa, ou seja, quando falham, são marcados como uma falha e permanecem assim até que você intervenha. No entanto, o Kue permite que você especifique isso, o que é importante para trabalhos como a transferência de um email, que após a falha, geralmente pode tentar novamente sem problemas. Para fazer isso, invocar o método .attempts() com um número.
queue . create ( 'email' , {
title : 'welcome email for tj'
, to : '[email protected]'
, template : 'welcome-email'
} ) . priority ( 'high' ) . attempts ( 5 ) . save ( ) ; As tentativas de tentativa de emprego são feitas assim que falharem, sem demora, mesmo que seu trabalho tenha um atraso no Job#delay . Se você deseja retardar as retalhos do trabalho sobre falhas (conhecidas como backoff), você pode usar o método de Job#backoff de diferentes maneiras:
// Honor job's original delay (if set) at each attempt, defaults to fixed backoff
job . attempts ( 3 ) . backoff ( true )
// Override delay value, fixed backoff
job . attempts ( 3 ) . backoff ( { delay : 60 * 1000 , type : 'fixed' } )
// Enable exponential backoff using original delay (if set)
job . attempts ( 3 ) . backoff ( { type : 'exponential' } )
// Use a function to get a customized next attempt delay value
job . attempts ( 3 ) . backoff ( function ( attempts , delay ) {
//attempts will correspond to the nth attempt failure so it will start with 0
//delay will be the amount of the last delay, not the initial delay unless attempts === 0
return my_customized_calculated_delay ;
} )No último cenário, a função fornecida será executada (via avaliação) em cada retificação para obter o próximo valor de atraso de tentativa, o que significa que você não pode fazer referência às variáveis externas/de contexto dentro dela.
Os produtores de empregos podem definir um valor de validade para o tempo que seu trabalho pode viver em estado ativo, de modo que, se os trabalhadores não responderam em tempo hábil, Kue falhará com TTL exceeded uma mensagem de erro impedindo que esse trabalho seja preso no estado ativo e estragando -se simultaneidade.
queue . create ( 'email' , { title : 'email job with TTL' } ) . ttl ( milliseconds ) . save ( ) ; Os logs específicos do trabalho permitem que você exponha informações à interface do usuário a qualquer momento da vida do trabalho. Para fazer isso, basta invocar job.log() , que aceita uma sequência de mensagens, bem como os argumentos variáveis para suporte do tipo Sprintf:
job . log ( '$%d sent to %s' , amount , user . name ) ;ou qualquer outra coisa (usa util.inspect () internamente):
job . log ( { key : 'some key' , value : 10 } ) ;
job . log ( [ 1 , 2 , 3 , 5 , 8 ] ) ;
job . log ( 10.1 ) ; O progresso do trabalho é extremamente útil para trabalhos de longa duração, como a conversão de vídeo. Para atualizar o progresso do trabalho, basta invocar job.progress(completed, total [, data]) :
job . progress ( frames , totalFrames ) ;Os dados podem ser usados para passar informações extras sobre o trabalho. Por exemplo, uma mensagem ou um objeto com alguns dados contextuais extras para o status atual.
Eventos específicos do trabalho são disparados nas instâncias Job via Redis Pubsub. Os seguintes eventos são suportados atualmente:
enqueue o trabalho agora está na filastart o trabalho agora está funcionandopromotion O trabalho é promovido do estado atrasado para a filaprogress o progresso do trabalho variando de 0 a 100failed attempt do trabalho falhou, mas ainda tem tentativas restantesfailed o trabalho falhou e não tem tentativas restantescomplete o trabalho concluiuremove o trabalho foi removidoPor exemplo, isso pode se parecer com o seguinte:
var job = queue . create ( 'video conversion' , {
title : 'converting loki's to avi'
, user : 1
, frames : 200
} ) ;
job . on ( 'complete' , function ( result ) {
console . log ( 'Job completed with data ' , result ) ;
} ) . on ( 'failed attempt' , function ( errorMessage , doneAttempts ) {
console . log ( 'Job failed' ) ;
} ) . on ( 'failed' , function ( errorMessage ) {
console . log ( 'Job failed' ) ;
} ) . on ( 'progress' , function ( progress , data ) {
console . log ( 'r job #' + job . id + ' ' + progress + '% complete with data ' , data ) ;
} ) ;Observe que os eventos no nível do trabalho não são garantidos para serem recebidos após as reinicializações do processo, uma vez que o processo reiniciado do Node.js perderá a referência ao objeto de trabalho específico. Se você deseja um manipulador de eventos mais confiável, procure eventos de fila.
Observe que o Kue armazena objetos de trabalho na memória até que estejam completos/não conseguem emitir eventos neles. Se você tiver uma enorme concorrência em trabalhos incompletos, desative esse recurso e use eventos de nível de fila para melhor escala de memória.
kue . createQueue ( { jobEvents : false } ) Como alternativa, você pode usar os events da função no nível do trabalho para controlar se os eventos são disparados para um trabalho no nível do trabalho.
var job = queue . create ( 'test' ) . events ( false ) . save ( ) ; Os eventos no nível da fila fornecem acesso aos eventos de nível de trabalho mencionados anteriormente, no entanto, escopo na instância Queue para aplicar a lógica no nível "global". Um exemplo disso é remover trabalhos concluídos:
queue . on ( 'job enqueue' , function ( id , type ) {
console . log ( 'Job %s got queued of type %s' , id , type ) ;
} ) . on ( 'job complete' , function ( id , result ) {
kue . Job . get ( id , function ( err , job ) {
if ( err ) return ;
job . remove ( function ( err ) {
if ( err ) throw err ;
console . log ( 'removed completed job #%d' , job . id ) ;
} ) ;
} ) ;
} ) ;Os eventos disponíveis são os mesmos mencionados em "eventos de emprego", por mais prefixados com "Job".
Os trabalhos atrasados podem estar programados para serem filmados para uma distância arbitrária no tempo, invocando o método .delay(ms) , passando o número de milissegundos em relação a agora . Como alternativa, você pode passar um objeto Date de JavaScript com um horário específico no futuro. Isso sinaliza automaticamente o Job como "atrasado".
var email = queue . create ( 'email' , {
title : 'Account renewal required'
, to : '[email protected]'
, template : 'renewal-email'
} ) . delay ( milliseconds )
. priority ( 'high' )
. save ( ) ;Kue verificará os trabalhos atrasados com um cronômetro, promovendo -os se o atraso agendado for excedido, padrão para uma verificação dos 1000 melhores empregos a cada segundo.
O processamento de trabalhos é simples com Kue. Primeiro, crie uma instância Queue assim como fazemos para criar trabalhos, fornecendo acesso a redis etc., depois invoque queue.process() com o tipo associado. Observe que, diferentemente do que o nome createQueue sugere, atualmente retorna uma instância Queue singleton. Para que você possa configurar e usar apenas um único objeto Queue no seu processo Node.js.
No exemplo seguinte, passamos o retorno de chamada done para email , quando ocorre um erro, invocamos done(err) para dizer a Kue que algo aconteceu, caso contrário, invocamos done() somente quando o trabalho estiver concluído. Se essa função responder com um erro, ela será exibida na interface do usuário e o trabalho será marcado como uma falha. O objeto de erro passado para feito, deve ser de Error de tipo padrão.
var kue = require ( 'kue' )
, queue = kue . createQueue ( ) ;
queue . process ( 'email' , function ( job , done ) {
email ( job . data . to , done ) ;
} ) ;
function email ( address , done ) {
if ( ! isValidEmail ( address ) ) {
//done('invalid to address') is possible but discouraged
return done ( new Error ( 'invalid to address' ) ) ;
}
// email send stuff...
done ( ) ;
} Os trabalhadores também podem aprovar o resultado do trabalho como o segundo parâmetro a ser done(null,result) para armazená -lo em Job.result Key. result também é passado através de manipuladores complete de eventos para que os produtores de empregos possam recebê -lo, se quiserem.
Por padrão, uma chamada para queue.process() aceitará apenas um trabalho de cada vez para o processamento. Para pequenas tarefas como enviar e -mails, isso não é ideal, portanto, podemos especificar os trabalhos ativos máximos para esse tipo, passando um número:
queue . process ( 'email' , 20 , function ( job , done ) {
// ...
} ) ; Os trabalhadores podem pausar e retomar temporariamente sua atividade. Ou seja, depois de ligar para pause eles não receberão empregos em seu retorno de chamada do processo até que resume seja chamado. A função pause FUNCIONACIALIZAMENTE ELATENDA ESTE trabalhador e usa a mesma funcionalidade interna que o método shutdown no desligamento gracioso.
queue . process ( 'email' , function ( job , ctx , done ) {
ctx . pause ( 5000 , function ( err ) {
console . log ( "Worker is paused... " ) ;
setTimeout ( function ( ) { ctx . resume ( ) ; } , 10000 ) ;
} ) ;
} ) ; Observe que o parâmetro ctx de Kue >=0.9.0 é o segundo argumento da função de retorno de chamada do processo e done é idiomaticamente sempre o último
Nota A assinatura do método pause é alterada de Kue >=0.9.0 para mover a função de retorno de chamada para o último.
Para um exemplo "real", digamos que precisamos compilar um PDF de vários slides com Node-Canvas. Nosso trabalho pode consistir nos seguintes dados, observe que, em geral, você não deve armazenar grandes dados no trabalho, é melhor armazenar referências como IDs, puxando-os durante o processamento.
queue . create ( 'slideshow pdf' , {
title : user . name + "'s slideshow"
, slides : [ ... ] // keys to data stored in redis, mongodb, or some other store
} ) ; Podemos acessar esses mesmos dados arbitrários dentro de um processo separado durante o processamento, através da propriedade job.data . No exemplo, renderizamos cada slide um por um, atualizando o log e o progresso do trabalho.
queue . process ( 'slideshow pdf' , 5 , function ( job , done ) {
var slides = job . data . slides
, len = slides . length ;
function next ( i ) {
var slide = slides [ i ] ; // pretend we did a query on this slide id ;)
job . log ( 'rendering %dx%d slide' , slide . width , slide . height ) ;
renderSlide ( slide , function ( err ) {
if ( err ) return done ( err ) ;
job . progress ( i , len , { nextSlide : i == len ? 'itsdone' : i + 1 } ) ;
if ( i == len ) done ( )
else next ( i + 1 ) ;
} ) ;
}
next ( 0 ) ;
} ) ; Queue#shutdown([timeout,] fn) sinaliza todos os trabalhadores para parar de processar após o trabalho atual do trabalho ativo. Os trabalhadores aguardam timeout milissegundos por seu trabalho ativo, para ser chamado ou marcar o trabalho ativo failed com o motivo do erro de desligamento. Quando todos os trabalhadores dizem a Kue, eles são parados, fn é chamado.
var queue = require ( 'kue' ) . createQueue ( ) ;
process . once ( 'SIGTERM' , function ( sig ) {
queue . shutdown ( 5000 , function ( err ) {
console . log ( 'Kue shutdown: ' , err || '' ) ;
process . exit ( 0 ) ;
} ) ;
} ) ; Observe que a assinatura do método de shutdown é alterada de Kue >=0.9.0 para mover a função de retorno de chamada para o último.
Todos os erros na Biblioteca de Clientes Redis ou na fila são emitidos no objeto Queue . Você deve se vincular a eventos error para impedir exceções não capturadas ou depurar erros de Kue.
var queue = require ( 'kue' ) . createQueue ( ) ;
queue . on ( 'error' , function ( err ) {
console . log ( 'Oops... ' , err ) ;
} ) ; Kue marca um trabalho completo/falhado quando done é chamado pelo seu trabalhador; portanto, você deve usar o manuseio de erros adequado para evitar exceções não capturadas no código do seu trabalhador e no processo node.js que sai antes de lidar com os trabalhos. Isso pode ser alcançado de duas maneiras:
queue . process ( 'my-error-prone-task' , function ( job , done ) {
var domain = require ( 'domain' ) . create ( ) ;
domain . on ( 'error' , function ( err ) {
done ( err ) ;
} ) ;
domain . run ( function ( ) { // your process function
throw new Error ( 'bad things happen' ) ;
done ( ) ;
} ) ;
} ) ;AVISO - Os domínios são descontinuados dos NodeJs com estabilidade 0 e não é recomendável usar.
Esta é a solução mais suave e melhor, no entanto, não está embutida com Kue. Por favor, consulte esta discussão. Você pode comentar sobre esse recurso na questão do Open Kue relacionado.
Você também pode usar promessas para fazer algo como
queue . process ( 'my-error-prone-task' , function ( job , done ) {
Promise . method ( function ( ) { // your process function
throw new Error ( 'bad things happen' ) ;
} ) ( ) . nodeify ( done )
} ) ;Mas isso não captará exceções em sua pilha de chamadas assíncronas como os domínios.
uncaughtException e desligamento graciosamente do Kue, no entanto, este não é um idioma de lidar com erros recomendado em JavaScript, pois você está perdendo o contexto de erro. process . once ( 'uncaughtException' , function ( err ) {
console . error ( 'Something bad happened: ' , err ) ;
queue . shutdown ( 1000 , function ( err2 ) {
console . error ( 'Kue shutdown result: ' , err2 || 'OK' ) ;
process . exit ( 0 ) ;
} ) ;
} ) ;Atualmente, Kue usa o gerenciamento do estado do trabalho do cliente e, quando Redis trava no meio dessas operações, alguns trabalhos presos ou inconsistências de índice acontecerão. A conseqüência é que um certo número de empregos ficará preso e será retirado pelo trabalhador somente quando novos empregos forem criados, se não forem criados mais novos empregos, eles ficaram para sempre. Então, sugerimos fortemente que você execute o cão de guarda para corrigir esse problema ligando:
queue . watchStuckJobs ( interval ) interval está em milissegundos e padrões para 1000ms
O Kue será refatorado para o gerenciamento de estado do trabalho totalmente atômico da versão 1.0 e isso acontecerá pelos scripts Lua e/ou combinação de BrPoplPush. Você pode ler mais aqui e aqui.
O objeto da fila tem dois tipos de métodos para falar sobre o número de trabalhos em cada estado
queue . inactiveCount ( function ( err , total ) { // others are activeCount, completeCount, failedCount, delayedCount
if ( total > 100000 ) {
console . log ( 'We need some back pressure here' ) ;
}
} ) ;Você também pode consultar um tipo de trabalho específico:
queue . failedCount ( 'my-critical-job' , function ( err , total ) {
if ( total > 10000 ) {
console . log ( 'This is tOoOo bad' ) ;
}
} ) ;e iterando os IDs de trabalho
queue . inactive ( function ( err , ids ) { // others are active, complete, failed, delayed
// you may want to fetch each id to get the Job object out of it...
} ) ; No entanto, o segundo não é escalado para grandes implantações, você pode usar métodos Job mais específicos:
kue . Job . rangeByState ( 'failed' , 0 , n , 'asc' , function ( err , jobs ) {
// you have an array of maximum n Job objects here
} ) ;ou
kue . Job . rangeByType ( 'my-job-type' , 'failed' , 0 , n , 'asc' , function ( err , jobs ) {
// you have an array of maximum n Job objects here
} ) ;Observe que os dois últimos métodos estão sujeitos a alterações nas versões Kue posteriores.
Se você não fez nada acima na seção de manuseio de erros ou em seus trabalhos ativos perdidos de alguma forma, poderá se recuperar quando o processo for reiniciado. Uma lógica cega seria reavaliar todos os empregos presos:
queue . active ( function ( err , ids ) {
ids . forEach ( function ( id ) {
kue . Job . get ( id , function ( err , job ) {
// Your application should check if job is a stuck one
job . inactive ( ) ;
} ) ;
} ) ;
} ) ;Nota Em uma implantação em cluster, seu aplicativo deve estar ciente de não envolver um trabalho válido, atualmente em processo por outros trabalhadores.
Dados dos trabalhos e índices de pesquisa Eat Up Redis Memory Space, para que você precisará de algum processo de manutenção de empregos nas implantações do mundo real. Sua primeira chance é usar a remoção automática de empregos na conclusão.
queue . create ( ... ) . removeOnComplete ( true ) . save ( ) Mas se você eventualmente/temporalmente precisar de dados de trabalho concluídos, poderá configurar um script de remoção de emprego sob demanda, como abaixo para remover n principais trabalhos preenchidos:
kue . Job . rangeByState ( 'complete' , 0 , n , 'asc' , function ( err , jobs ) {
jobs . forEach ( function ( job ) {
job . remove ( function ( ) {
console . log ( 'removed ' , job . id ) ;
} ) ;
} ) ;
} ) ; Observe que você deve fornecer tempo suficiente para .remove chamadas em cada objeto de trabalho a ser concluído antes que seu processo saia, ou os índices de trabalho vazarão
Por padrão, o Kue se conectará ao REDIS usando as configurações padrão do cliente (os padrões da porta para 6379 , o host inadimplente para 127.0.0.1 , o prefixo padrão para q ). Queue#createQueue(options) Aceita opções de conexão Redis no options.redis key.
var kue = require ( 'kue' ) ;
var q = kue . createQueue ( {
prefix : 'q' ,
redis : {
port : 1234 ,
host : '10.0.50.20' ,
auth : 'password' ,
db : 3 , // if provided select a non-default redis db
options : {
// see https://github.com/mranney/node_redis#rediscreateclient
}
}
} ) ; prefix controla os nomes de chave usados no redis. Por padrão, isso é simplesmente q . O prefixo geralmente não deve ser alterado, a menos que você precise usar uma instância Redis para vários aplicativos. Também pode ser útil para o fornecimento de um teste de teste isolado em seu aplicativo principal.
Você também pode especificar as informações de conexão como uma string de URL.
var q = kue . createQueue ( {
redis : 'redis://example.com:1234?redis_option=value&redis_option=value'
} ) ; Como o Node_redis suporta soquetes do UNIX Domain, você também pode dizer a Kue para fazê -lo. Consulte o soquete UNIX no domínio para a configuração do seu servidor Redis.
var kue = require ( 'kue' ) ;
var q = kue . createQueue ( {
prefix : 'q' ,
redis : {
socket : '/data/sockets/redis.sock' ,
auth : 'password' ,
options : {
// see https://github.com/mranney/node_redis#rediscreateclient
}
}
} ) ; Qualquer biblioteca de clientes Node.js Redis que esteja em conformidade (ou quando adaptada) à API Node_redis pode ser injetada no Kue. Você deve fornecer apenas uma função createClientFactory como uma fábrica de conexão Redis, em vez de fornecer opções de conexão Node_redis.
Abaixo está um código de amostra para permitir que o Redis-Sentinel se conecte ao Redis Sentinel para o failover de mestre/escravo automático.
var kue = require ( 'kue' ) ;
var Sentinel = require ( 'redis-sentinel' ) ;
var endpoints = [
{ host : '192.168.1.10' , port : 6379 } ,
{ host : '192.168.1.11' , port : 6379 }
] ;
var opts = options || { } ; // Standard node_redis client options
var masterName = 'mymaster' ;
var sentinel = Sentinel . Sentinel ( endpoints ) ;
var q = kue . createQueue ( {
redis : {
createClientFactory : function ( ) {
return sentinel . createClient ( masterName , opts ) ;
}
}
} ) ; Observe que todos os códigos do cliente <0.8.x devem ser refaturados para passar as opções Redis para Queue#createQueue em vez de um estilo remendado de macaco, substituindo redis#createClient ou serão quebrados no Kue 0.8.x
var Redis = require ( 'ioredis' ) ;
var kue = require ( 'kue' ) ;
// using https://github.com/72squared/vagrant-redis-cluster
var queue = kue . createQueue ( {
redis : {
createClientFactory : function ( ) {
return new Redis . Cluster ( [ {
port : 7000
} , {
port : 7001
} ] ) ;
}
}
} ) ; A interface do usuário é uma pequena aplicação expressa. Um script é fornecido no bin/ para executar a interface como um aplicativo independente com configurações padrão. Você pode passar as opções para a porta, Redis-URL e prefixo. Por exemplo:
node_modules/kue/bin/kue-dashboard -p 3050 -r redis://127.0.0.1:3000 -q prefix
Você também pode dispará -lo de outro aplicativo:
var kue = require ( 'kue' ) ;
kue . createQueue ( ... ) ;
kue . app . listen ( 3000 ) ;O título é o padrão de "Kue", para alterar este invocar:
kue . app . set ( 'title' , 'My Application' ) ; Observe que, se você estiver usando opções de Kue não padrão, kue.createQueue(...) deve ser chamado antes de acessar kue.app .
Você também pode usar a interface da web Kue-Ui contribuída por Arnaud Bénard
Junto com o Ui Kue, também expõe uma API JSON, que é utilizada pela interface do usuário.
Empregos de consulta, por exemplo, "Get /Job /Search? Q = Avi Video":
[ "5" , "7" , "10" ] Por padrão, o Kue indexa todo o objeto de dados do trabalho para pesquisa, mas isso pode ser personalizado por meio de chamadas de Job#searchKeys para dizer a Kue quais chaves nos dados do trabalho para criar índice para:
var kue = require ( 'kue' ) ;
queue = kue . createQueue ( ) ;
queue . create ( 'email' , {
title : 'welcome email for tj'
, to : '[email protected]'
, template : 'welcome-email'
} ) . searchKeys ( [ 'to' , 'title' ] ) . save ( ) ; O recurso de pesquisa é desligado por padrão de Kue >=0.9.0 . Leia mais sobre isso aqui. Você deve ativar os índices de pesquisa e adicionar vermelhos em suas dependências, se precisar:
var kue = require ( 'kue' ) ;
q = kue . createQueue ( {
disableSearch : false
} ) ; npm install reds --save
Atualmente responde com a contagem de estados e o tempo de atividade do trabalhador em milissegundos:
{ "inactiveCount" : 4 , "completeCount" : 69 , "activeCount" : 2 , "failedCount" : 0 , "workTime" : 20892 } Obtenha um emprego por :id :
{ "id" : "3" , "type" : "email" , "data" : { "title" : "welcome email for tj" , "to" : "[email protected]" , "template" : "welcome-email" } , "priority" : - 10 , "progress" : "100" , "state" : "complete" , "attempts" : null , "created_at" : "1309973155248" , "updated_at" : "1309973155248" , "duration" : "15002" } Obter emprego :id :
[ 'foo' , 'bar' , 'baz' ] Obtenha empregos com o intervalo especificado :from :to : por exemplo "/jobs/0..2", onde :order pode ser "asc" ou "desc":
[ { "id" : "12" , "type" : "email" , "data" : { "title" : "welcome email for tj" , "to" : "[email protected]" , "template" : "welcome-email" } , "priority" : - 10 , "progress" : 0 , "state" : "active" , "attempts" : null , "created_at" : "1309973299293" , "updated_at" : "1309973299293" } , { "id" : "130" , "type" : "email" , "data" : { "title" : "welcome email for tj" , "to" : "[email protected]" , "template" : "welcome-email" } , "priority" : - 10 , "progress" : 0 , "state" : "active" , "attempts" : null , "created_at" : "1309975157291" , "updated_at" : "1309975157291" } ] O mesmo que acima, restringindo :state que é um dos:
- active
- inactive
- failed
- complete
O mesmo que acima, por mais restrito a :type e :state .
Excluir trabalho :id :
$ curl -X DELETE http://local:3000/job/2
{"message":"job 2 removed"}
Crie um trabalho:
$ curl -H "Content-Type: application/json" -X POST -d
'{
"type": "email",
"data": {
"title": "welcome email for tj",
"to": "[email protected]",
"template": "welcome-email"
},
"options" : {
"attempts": 5,
"priority": "high"
}
}' http://localhost:3000/job
{"message": "job created", "id": 3}
Você pode criar vários trabalhos ao mesmo tempo passando uma matriz. Nesse caso, a resposta também será uma matriz, preservando a ordem:
$ curl -H "Content-Type: application/json" -X POST -d
'[{
"type": "email",
"data": {
"title": "welcome email for tj",
"to": "[email protected]",
"template": "welcome-email"
},
"options" : {
"attempts": 5,
"priority": "high"
}
},
{
"type": "email",
"data": {
"title": "followup email for tj",
"to": "[email protected]",
"template": "followup-email"
},
"options" : {
"delay": 86400,
"attempts": 5,
"priority": "high"
}
}]' http://localhost:3000/job
[
{"message": "job created", "id": 4},
{"message": "job created", "id": 5}
]
Nota: Ao inserir vários trabalhos a granel, se uma inserção falhar, Kue continuará processando os trabalhos restantes em ordem. A matriz de resposta conterá os IDs dos trabalhos adicionados com sucesso, e qualquer elemento com falha será um objeto que descreve o erro: {"error": "error reason"} .
O exemplo abaixo mostra como você pode usar o cluster para espalhar a carga de processamento de tarefas nas CPUs. Consulte a documentação do módulo de cluster para obter exemplos mais detalhados sobre como usá -lo.
Quando cluster .isMaster o arquivo está sendo executado no contexto do processo mestre; nesse caso, você pode executar tarefas que você deseja apenas uma vez, como iniciar o aplicativo da web com Kue. A lógica no bloco else é executada por trabalhador .
var kue = require ( 'kue' )
, cluster = require ( 'cluster' )
, queue = kue . createQueue ( ) ;
var clusterWorkerSize = require ( 'os' ) . cpus ( ) . length ;
if ( cluster . isMaster ) {
kue . app . listen ( 3000 ) ;
for ( var i = 0 ; i < clusterWorkerSize ; i ++ ) {
cluster . fork ( ) ;
}
} else {
queue . process ( 'email' , 10 , function ( job , done ) {
var pending = 5
, total = pending ;
var interval = setInterval ( function ( ) {
job . log ( 'sending!' ) ;
job . progress ( total - pending , total ) ;
-- pending || done ( ) ;
pending || clearInterval ( interval ) ;
} , 1000 ) ;
} ) ;
} Isso criará um processador de empregos email (trabalhador) de acordo com cada um dos núcleos da CPU da sua máquina, com cada um, você pode lidar com 10 trabalhos de email simultâneos, levando ao total de 10 * N empregos de email simultâneos processados em sua máquina N Core.
Agora, quando você visita a interface do usuário de Kue no navegador, verá que os empregos estão sendo processados aproximadamente N vezes mais rápido! (Se você possui N núcleos).
Através do uso da montagem de aplicativos, você pode personalizar o aplicativo da Web, habilitando o TLS ou adicionando middleware adicional, como basic-auth-connect .
$ npm install --save basic-auth-connect var basicAuth = require ( 'basic-auth-connect' ) ;
var app = express . createServer ( { ... tls options ... } ) ;
app . use ( basicAuth ( 'foo' , 'bar' ) ) ;
app . use ( kue . app ) ;
app . listen ( 3000 ) ; Habilite o modo de teste para empurrar todos os trabalhos para uma matriz jobs . Faça afirmações contra os trabalhos nessa matriz para garantir que o código em teste esteja envolvendo corretamente os trabalhos.
queue = require ( 'kue' ) . createQueue ( ) ;
before ( function ( ) {
queue . testMode . enter ( ) ;
} ) ;
afterEach ( function ( ) {
queue . testMode . clear ( ) ;
} ) ;
after ( function ( ) {
queue . testMode . exit ( )
} ) ;
it ( 'does something cool' , function ( ) {
queue . createJob ( 'myJob' , { foo : 'bar' } ) . save ( ) ;
queue . createJob ( 'anotherJob' , { baz : 'bip' } ) . save ( ) ;
expect ( queue . testMode . jobs . length ) . to . equal ( 2 ) ;
expect ( queue . testMode . jobs [ 0 ] . type ) . to . equal ( 'myJob' ) ;
expect ( queue . testMode . jobs [ 0 ] . data ) . to . eql ( { foo : 'bar' } ) ;
} ) ;IMPORTANTE: Por padrão, os trabalhos não são processados quando criados durante o modo de teste. Você pode ativar o processamento de empregos passando fiéis ao testmode.enter
before ( function ( ) {
queue . testMode . enter ( true ) ;
} ) ; Adoramos contribuições!
Ao contribuir, siga as regras simples:
(A licença do MIT)
Copyright (c) 2011 LearnBoost <[email protected]>
A permissão é concedida, gratuita, a qualquer pessoa que obtenha uma cópia deste software e arquivos de documentação associados (o 'software'), para lidar com o software sem restrição, inclusive sem limitação os direitos de uso, copiar, modificar, mesclar, mesclar .
O aviso de direitos autorais acima e este aviso de permissão devem ser incluídos em todas as cópias ou em partes substanciais do software.
O software é fornecido 'como está', sem garantia de qualquer tipo, expresso ou implícito, incluindo, entre outros, as garantias de comercialização, aptidão para uma finalidade específica e não innoculação. Em nenhum caso os autores ou detentores de direitos autorais serão responsabilizados por qualquer reclamação, danos ou outro passivo, seja em uma ação de contrato, delito ou não, decorrente de, fora ou em conexão com o software ou o uso ou outras negociações nos Software.
