fermata elaborazione tupla in taluni bullone

Question

Ho una topologia per esempio composto da bulloni 1 becco e 4

spout A -> bolt B -> bolt C -> bolt E 
        -> bolt D 

Solo se qualche dichiarazione condizionale nel bullone B è vero, allora passa una tupla per foro C e bullone D .

e solo se qualche dichiarazione condizionale nel bullone C è vero allora si passa una tupla di bullone E.

Così singola tupla può raggiungere solo bullone B o (bullone C e D).

Sto usando BaseBasicBolt che a mia conoscenza esegue automaticamente l'operazione dopo che collector.emit viene chiamato.

Per esempio eseguire metodo bullone B è come qui di seguito

public class boltB extends BaseBasicBolt { 
    public void execute(Tuple tuple, BasicOutputCollector collector) { 
     ...some logic goes here 
     if (response.getCount() > 0) { 
      collector.emit(new Values(tuple.getString(0))); 
     } 
    } 
} 

Quindi, se collector.emit non si chiama, credo tuple dalla bocca di erogazione è riuscita perché vedo da tempesta ui che quasi tutte le tuple di beccuccio è fallito.

In questo caso, dove dovrei chiamare "ack" per spout per non considerarlo come tupla fallita?

Answer 1

Quello che stai facendo è corretto per la logica che stai implementando. Non è necessario chiamare esplicitamente lo ack(). Quando si utilizza BaseBasicBolt, ciascuna tupla viene attivata dopo il metodo execute() da BasicBoltExecutor. Per le tuple fallite, dovresti controllare le eccezioni. Prova anche a guardare UI Storm per le anomalie in tuple emesse/eseguite/fallite per ogni beccuccio e bullone.

Answer 2

Quando hai BaseBasicBolt, l'acking è fatto per te, anche se non stai emettendo nulla.

L'istanza BaseBasicBolt viene eseguito in BasicBoltExecutor, cui eseguire() metodo è il seguente:

public void execute(Tuple input) { 
    _collector.setContext(input); 
    try { 
     _bolt.execute(input, _collector); 
     _collector.getOutputter().ack(input); 
    } catch(FailedException e) { 
     if(e instanceof ReportedFailedException) { 
      _collector.reportError(e); 
     } 
     _collector.getOutputter().fail(input); 
    } 
} 

Quindi, al fine di interrompere l'elaborazione di una tupla, non emettono, dopo la chiamata esecuzione, essa sarà acked. Dal momento che non ci sono più bulloni per eseguire il richiamo Ack nello spout si chiamerà

Spero che sia la risposta alle vostre domande