distributed computing - tutorial - Manera adecuada de ACK en Storm en una cadena de tornillos.

storm rodenticida

Question

Solo quiero asegurarme de que entiendo cómo funciona Ack-ing en Storm. Tengo 1 pico y 2 tornillos encadenados juntos. Spout emite la tupla a Bolt1, que a su vez emitirá una tupla a Bolt 2. Quiero que Bolt 2 acepte la tupla inicial enviada desde Spout y no estoy seguro de cómo hacerlo.

Para garantizar la tolerancia a fallos (es decir, las tuplas están reenviadas), quiero reconocer en el perno 2 la tupla emitida por Spout en caso de que falle en algún lugar del proceso para poder reenviarla.

Considera este ejemplo:

Canalón:

 _collector.emit(new Values(queue.dequeue())

Perno 1:

def execute(tuple: Tuple) {
 _collector.emit(tuple, new Values("stuff"))
}

En este punto, la tupla es la tupla enviada por el pico. Puedo reconocerlo aquí sin problemas. Ahora agregue otro perno que escuche las tuplas emitidas por Bolt1.

Perno 2:

def execute(tuple2: Tuple) {
 _collector.emit(tuple2, new Values("foo"))
}

En este punto, la tupla en tupla2 es la tupla enviada desde Bolt1 (la que tiene la cadena "cosas" en ella).
Por lo tanto, si envío un recibo en Bolt2, esto se aplicará a la tupla de Bolt1, no al enviado desde Spout. ¿Correcto?

¿Cómo puedo reconocer la tupla que se envió desde el pico? ¿Debo llevar el pico inicial a todos los otros surtidores para poder recuperarlo en el último Tornillo y reconocerlo?

Leí los tutoriales de Nathan y tuve la impresión de que podía aceptar la tupla recibida en Bolt1 (de Spout) justo allí después de emitir tuple2. Esto vincularía la tupla2 recién emitida a la tupla original enviada por Spout, de modo que cuando Bolt2 acks la tupla 2, en realidad, la acople de la tupla original. ¿Es esto cierto?

Avísame si me falta algo en mi explicación.

Answer 1

Necesitas anchor tupla. Echa un vistazo a Procesamiento de mensajes de garantía. Y especialmente necesitas esto:

List<Tuple> anchors = new ArrayList<Tuple>();
anchors.add(tuple1);
anchors.add(tuple2);
_collector.emit(anchors, new Values(1, 2, 3));

Answer 2

Para aquellos interesados, he encontrado una solución preguntando sobre el grupo de la tormenta. Lo que necesito es en Spout para emitir tuplas de la siguiente manera (con una identificación única):

Canalón:

 //ties in tuple to this UID
 _collector.emit(new Values(queue.dequeue(), *uniqueID*) 

Luego, Bolt1 aceptará la tupla solo después de que la emita a Bolt2.

Perno 1:

 //emit first then ack
 _collector.emit(tuple, new Values("stuff")) //**anchoring** - read below to see what it means
 _collector.ack(tuple) 

En este punto, la tupla de Spout ha sido tocada en Bolt1, pero al mismo tiempo, la tupla "material" recién emitida a Bolt2 está "anclada" a la tupla de Spout. Lo que esto significa es que aún debe ser reconocido más tarde, de lo contrario, en el tiempo de espera se reenviará por pico.

Perno 2:

 _collector.ack(tuple) 

Bolt2 necesita aceptar la tupla recibida de Bolt1, que enviará la última confirmación que Spout estaba esperando. Si en este punto Bolt2 emite la tupla, entonces debe haber un Bolt3 que lo obtenga y lo reconozca. Si la tupla no está en el último punto, Spout la expirará y la reenviará.

Cada vez que se realiza el anclaje en una declaración emitida de perno a perno, se construye un nuevo nodo en una estructura de "árbol" ... bueno, más bien como una lista en mi caso, ya que nunca envío la misma tupla a 2 o más tuplas. tener una relación de 1 a 1.

Todos los nodos en el árbol deben ser activados, y solo entonces la tupla se marca como totalmente llegada. Si la tupla no está activada y se envía con un UID y se ancla más adelante, se conservará en la memoria para siempre (hasta que se active).

Espero que esto ayude.

Answer 3

Puedes leer sobre esto en la documentación oficial .

Si desea realizar un seguimiento de la ejecución de sus touples a través de todos los tornillos, puede usar BaseBasicBolt como clase principal donde este comportamiento ya está definido.

En cualquier otro caso de uso (es decir, si desea que se reconozca el touple antes de la ejecución en el último tornillo), debe definir manualmente los enlaces entre sus tuplas (llamado anclaje). Consulte la documentación.