# E-commerce con carrello temporizzato

**URL:** <https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768>\
**Category:** IT\
**Created:** [March 28, 2015, 9:28am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768 "2015-03-28T09:28:46Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![addis\_a](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/a/c4cdca/32.png) [@addis\_a](https://www.ruby-forum.com/u/addis_a)\
**Post date:** [March 28, 2015, 9:28am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/1 "2015-03-28T09:28:46Z")

</div>

Ciao a tutti,  
innanzitutto grazie per il vostro aiuto,  
avrei un esigenza di un cliente …

dovrei realizzare un carrello temporizato …

ho creato la seguente entità

CART

- created-at
- update\_at
- expired\_at  
…  
…  
…

ora secondo voi quale è la migliore strada da seguire per creare un  
controllo sul carrello ??

supponendo che ogni 15 min, il carrello si deve svuotare ??

Grazie mille.

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 28, 2015, 9:37am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/2 "2015-03-28T09:37:18Z")

</div>

Ciao Roberto, le opzioni sono tante (worker Sidekiq, per esempio), ma  
prima  
di analizzarle in dettaglio penso sarebbe sensato descrivere la tua  
visione  
dell’esperienza utente relativa a questo aspetto.  
On Mar 28, 2015 9:28 AM, “Roberto S.” [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 28, 2015, 9:41am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/3 "2015-03-28T09:41:19Z")

</div>

ciao Maurizio … grazie per la risposta …

io mi stavo immaginando un controllore in crontab che andasse a  
eliminare tutti i carrelli scaduti …

te mi consigli Sidekiq … come potrei integrare i suoi worker nella mia  
reale esigenza ??

per quanto riguarda l’esperienza utente … ho bisogno del contatore  
carrello sempre ben visibile come un count down …

grazie mille.

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 28, 2015, 10:46pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/4 "2015-03-28T22:46:43Z")

</div>

Sidekiq si occupa solo di lanciare un job asincrono.  
Per la soluzione che stai pensando te puoi usare whenever (andr comunque  
a  
scrivere in crontab)

Altrimenti potresti provare delayed\_job che ti permette di lanciare un  
job  
async ad un orario specifico.

Il giorno sab 28 mar 2015 alle ore 09:41 Roberto S. \<  
removed\_email\_address@domain.invalid\> ha scritto:

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 28, 2015, 10:57pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/5 "2015-03-28T22:57:13Z")

</div>

sì, ripensando un attimo al tuo caso d’uso, al posto di Sidekiq,  
consiglio  
anche io whenever, in modo da impostare un’esecuzione periodica di uno  
sweeper dei carrelli scaduti.  
Un dubbio però riguardo gli attributi che hai elencato prima: ti basi  
sull’attributo expired\_at per capire se un carrello è scaduto?  
Non sarebbe meglio evitare quell’attributo e basarsi solamente  
sull’attributo updated\_at, in modo da verificare se cart.updated\_at +  
15.minutes \>= DateTime.now e in tal caso cancellarlo dal database o  
impostare un booleano (active)?

2015-03-28 22:45 GMT+01:00 Daniele P. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 28, 2015, 11:39pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/6 "2015-03-28T23:39:56Z")

</div>

Se il tempo di scadenza è costante, expired\_at non ti serve.  
A seconda della mole di lavoro del tuo database, fare una query molto  
frequente con un filtro su un campo datetime non è il massimo, quindi  
sto pesando che sarebbe interessante imposare un booleano ad un  
determinato tempo.

Se stai giù usando Sidekiq nell’applicazione, potresti fare un worker  
che setta un booleano `expired' nel futuro, usando `perform\_at`.  
La cosa funzionerebbe così.

class Carrello \< ActiveRecord::Base  
after\_commit(on: :update) do |record| # mi piace tanto passare  
record come variabile locale qui non so perchè  
CarrelloExpireCheckWorker.perform\_at(15.minutes.from\_now, record.id)  
end

def expire\_if\_expired  
update\_column(:expired, true) if updated\_at \< 15.minutes.ago # lo  
so questa si può comprimere ma così è più leggibile  
end  
end

class CarrelloExpireCheckWorker  
include Sidekiq::Worker

def perform(record\_id)  
Carrello.find(record.id).expire\_if\_expired # questo fallo fare al  
modello, è il posto giusto per farlo, ti potrebbe servire in altre  
situazioni  
end  
end

In questo modo ad ogni update del carrello viene fatto un controllo 15  
minuti dopo. Se vengono fatti altri update nel frattempo, i più vecchi  
sidekiq jobs nella coda non aggiorneranno il flag, perchè nel  
frattempo updated\_at si sarà spostato avanti nel tempo.

Vale la pena fare tutto questo? Forse no, però ti evita di mettere  
qualcosa nel cron che fa una query ogni minuto.

2015-03-28 22:56 GMT+01:00 maurizio de magnis  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 4:26pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/7 "2015-03-29T16:26:53Z")

</div>

2015-03-28 23:38 GMT+01:00 Fabrizio R. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):  
[cut]

> Vale la pena fare tutto questo? Forse no, però ti evita di mettere  
> qualcosa nel cron che fa una query ogni minuto.

Con whenever può impostare un controllo periodico (non necessariamente  
ogni  
minuto, anzi, ipotizziamolo anche ogni 6 ore) al quale affiancare un  
controllo “quando serve”.

Mi spiego meglio: con whenever cerchi di fare pulizia tra il cimitero  
dei  
carrelli, ovvero quelli che sono stati iniziati e poi abbandonati,  
quindi  
per questa tipologia di carrelli, non hai la necessità di invalidazione  
tempestiva, perché l’unico scopo dello sweeper è fare pulizia nel  
database.

Se poi vuoi che quando un utente aggiorna un carrello lasciato a riposo  
per  
più di 15 minuti, questo venga resettato, allora basta aggiungere un  
controllo di “freschezza” del carrello ad ogni aggiornamento del  
carrello  
stesso.

Così salvi capra e cavoli: relativa semplicità d’implementazione,  
consistenza dei dati ed efficienza dei processi.

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 5:33pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/8 "2015-03-29T17:33:47Z")

</div>

E comunque non riesco a farmi piacere le callback nei model  
ActiveRecord…  
:-/  
Appesantire il layer di persistenza, con addirittura il lancio di un  
worker  
per ogni update…  
#esepoitenepenti ?

2015-03-29 16:25 GMT+02:00 maurizio de magnis  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 8:58pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/9 "2015-03-29T20:58:30Z")

</div>

Sicuramente quello che ho scritto è sovradimensionato per il problema  
da risolvere, ma mi è passato per la testa e mi faceva piacere  
condividerlo. Potrebbero esserci scenari analoghi per i quali una  
soluzione del genere ha più senso. Ripulire il cimitero dei carrelli  
una volta al giorno va più che bene nella maggior parte delle  
situazioni.

Riguardo l’appesantimento, non lo vedo tanto un appesantimento. Alla  
fine il modello sta mandando un segnale nell’universo ‘ho aggiornato  
updated\_at su questo record’. Ci sono molti modi per tenere il modello  
all’oscuro dei dettagli dell’implementazione.

Tanto per scherzare un pò con l’economia delle cose: nella soluzione  
Cart Samatary se in un anno nessuno usa il carrello avrai fatto 365  
query a vuoto 🙂

2015-03-29 17:32 GMT+02:00 maurizio de magnis  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 11:07pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/10 "2015-03-29T23:07:41Z")

</div>

L’approccio che hai descritto te è simile a quello di Fabrizio, che usa  
Sidekiq.  
Sinceramente penso che sia l’approccio a worker (sidekiq o delayed\_job o  
vattelapesca) +15 minuti post update che quello dello sweeper via  
whenever/cron con il check durante l’update siano validi, con differenze  
di  
efficienza difficilmente rilevabili in contesti anche di media entità.

Non sono un grande fan di delayed\_job, soprattutto perché penso che sidekiq faccia meglio.

2015-03-29 22:51 GMT+02:00 Daniele P. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 11:11pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/11 "2015-03-29T23:11:10Z")

</div>

Il problema del background job in questo caso è che

1. non hai garanzia di precisione temporale, per cui ti potresti trovare  
in  
casi in cui il carrello sarebbe vuoto prima del tempo stabilito o pieno  
dopo
2. non hai garanzia di esecuzione, cioè se il demone è giù per qualche  
motivo ti ritroveresti coi carrelli pieni fin quando il demone non torna  
su

Io farei un check in lettura con un after\_find di sto tipo:

class Cart  
after\_find :timeout\_reset

def timeout\_reset  
if created\_at (o quel che l’è) \< 15.minutes.from\_now  
empty  
end  
end

def empty  
end  
end

–

Maurizio De Santis

Il giorno 29 marzo 2015 22:51, Daniele P.  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
ha scritto:

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 10:52pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/12 "2015-03-29T22:52:44Z")

</div>

Scusate ma l’idea di delayed\_job sarebbe davvero cosí brutta?

Una cosa tipo:

```
handle_asynchronously :reset_cart, :run_at => Proc.new { 15

```

.minutes.from\_now }

dopo 15 minuti il carrello si resetta.

Il giorno dom 29 mar 2015 alle ore 17:32 maurizio de magnis \<  
removed\_email\_address@domain.invalid\> ha scritto:

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 11:18pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/13 "2015-03-29T23:18:10Z")

</div>

2015-03-29 20:57 GMT+02:00 Fabrizio R. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):  
[cut]

> Riguardo l’appesantimento, non lo vedo tanto un appesantimento. Alla  
> fine il modello sta mandando un segnale nell’universo ‘ho aggiornato  
> updated\_at su questo record’. Ci sono molti modi per tenere il modello  
> all’oscuro dei dettagli dell’implementazione.

con una sola callback presente, ok, ma è la direzione che cerco di  
evitare.  
Per esempio, se in futuro dovrò fare un batch import con degli update  
sul  
model, non voglio dovermi inventare degli stratagemmi per evitare che le  
callback intervengano (post in ml di qualche tempo fa ;-)).

Chiamala convenzione, ma mi sento molto più sicuro quando so che il  
layer  
ActiveRecord si preoccupa solo della persistenza.

Anche perché la stessa funzionalità la puoi ottenere senza perdere in  
pulizia e concisione: nel contesto di update del cart  
(CartsController#{create,update} ?), dopo l’update/create posso lanciare  
esplicitamente CarrelloExpireCheckWorker.perform\_at(15.minutes.from\_now,  
record.id) o, se voglio proprio esagerare e/o se i contesti di  
aggiornamento sono un numero significativo:

class CartValidityChecker  
def initialize(cart:)  
@cart = cart  
end

def perform  
CarrelloExpireCheckWorker.perform\_at(15.minutes.from\_now, @cart.id  
[http://record.id/](http://record.id/))  
end  
end

e nei contesti di aggiornamento del cart:

CartValidityChecker.new(cart: cart).perform

in modo da aver un accentramento della logica responsabile  
dell’aggiornamento del cart.

Tanto per scherzare un pò con l’economia delle cose: nella soluzione

> Cart Samatary se in un anno nessuno usa il carrello avrai fatto 365  
> query a vuoto 🙂

in tal caso ripenserei alla sostenibilità del mio e-commerce 😃

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 30, 2015, 9:39am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/14 "2015-03-30T09:39:04Z")

</div>

2015-03-29 23:10 GMT+02:00 Maurizio De Santis  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> Il problema del background job in questo caso è che
> 
> 1. non hai garanzia di precisione temporale, per cui ti potresti trovare in  
> casi in cui il carrello sarebbe vuoto prima del tempo stabilito o pieno dopo  
> Non mi sembra un gran problema, a meno che non sia una gara di  
> carrelli a cronometro, immagino tu parli di tempi trascurabili  
> nell’ordine del secondo.

> 1. non hai garanzia di esecuzione, cioè se il demone è giù per qualche  
> motivo ti ritroveresti coi carrelli pieni fin quando il demone non torna su  
> Il demone non deve essere giù, come non deve essere giù il webserver.  
> È il prezzo da pagare se vuoi usare un background jobs nella tua  
> architettura, cosa di cui prima o poi avrai bisogno comunque.

> end

Interessante l’after\_find, non lo ricordavo. Mai usato, però porebbe  
essere utile. Comunque anche in questo caso è un callback, per cui  
potrebbe capitare la volta in cui vuoi fare una find che escluda  
quella logica. Caso che secondo me è molto più comune che non voler  
escludere una callback after\_save. Oltre tutto, per skippare una  
callback su una istanza puoi usare una variabile di istanza. Per  
skippare una callback su class method è un pò più complicato.

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 29, 2015, 11:12pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/15 "2015-03-29T23:12:55Z")

</div>

Scusate, la empty voleva essere

def empty

# TODO: implementazione svuotamento carrello

end

–

Maurizio De Santis

Il giorno 29 marzo 2015 23:10, Maurizio De Santis \<  
removed\_email\_address@domain.invalid\> ha scritto:

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 30, 2015, 11:30am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/16 "2015-03-30T11:30:10Z")

</div>

> Non mi sembra un gran problema, a meno che non sia una gara di  
> carrelli a cronometro, immagino tu parli di tempi trascurabili  
> nell’ordine del secondo.

Prendiamo il caso in cui worker sia occupato nel momento in cui deve  
partire il job che svuota il carrello, ed il worker ci mette 5 secondi a  
finire il job che sta facendo: in questo caso ti troveresti il job del  
cart  
spostato 5 secondi pi avanti. 5 come 15 come boh, dipende da quanto ci  
mette il worker a finire la queue precedente al job del cart.

Non so per questo caso quanto facilmente si verifichi nella vita vera,  
immagino dipenda dalla situazione dei jobs.

–

Maurizio De Santis

Il giorno 30 marzo 2015 10:02, Roberto S.  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
ha scritto:

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 30, 2015, 11:31am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/17 "2015-03-30T11:31:03Z")

</div>

Se appesantisci il server dipende da troppe cose per poterlo dire ora,  
quindi dovresti dotarti di strumenti di analisi e monitoraggio per  
capirlo strada facendo. Se non hai particolari esigenze vai con la  
soluzione pi semplice lasciando perdere i background jobs, una  
pulizia periodica dei carrelli morti sufficiente, come gi detto,  
nella maggior parte dei casi.

Le differenze con Sidekiq sono pi che altro nella velocit dello  
smaltimento delle code, se non ricordo male.

2015-03-30 10:02 GMT+02:00 Roberto S.  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 30, 2015, 10:02am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/18 "2015-03-30T10:02:51Z")

</div>

ciao a tutti e grazie per i vostri consigli,

vado ad esplicitare meglio le funzionalità:

il carrello a ogni aggiunta del prodotto dovrà aggiornare la sua  
validità

ogni 15 minuti i carrelli che hanno la loro validità (scaduta), dovranno  
cessare di vivere e i loro prodotti dovranno riacquistare la quantità  
sottratta.

penso che tutte le soluzioni elencate siano ottime per la risoluzione  
del problema.

che differenza cè nell’utilizzare delayed\_job OR Sidekiq ??

posso utilizzare uno dei due per rinnovare la vita al carrello (magari  
con un after\_save OR after\_update)

e un cronjob per pulire i carrelli morti???

unica cosa il cronjob dovrebbe partire ogni 15 min, rischio di  
appesantire il server ??

Grazie.

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 30, 2015, 11:46am UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/19 "2015-03-30T11:46:02Z")

</div>

> Prendiamo il caso in cui worker sia occupato nel momento in cui deve  
> partire il job che svuota il carrello, ed il worker ci mette 5 secondi a  
> finire il job che sta facendo: in questo caso ti troveresti il job del cart  
> spostato 5 secondi pi avanti. 5 come 15 come boh, dipende da quanto ci  
> mette il worker a finire la queue precedente al job del cart.

Si questo scenario possibile. E comunque ancora nei 15 secondi  
l’expiry di un carrello secondo me un range tollerabile. Anche un  
minuto se vogliamo. Ma capisco il punto.

Mettiamola cos, il tutto funziona se il tuo sistema di background  
jobs in salute. E per in salute intendo avere sempre a disposizione  
un “congruo” numero di workers “idle” per fare il lavoro che ci si  
aspetta nei tempi che ci si aspetta.

---

<div class="post-metadata">

**Author:** ![rsaccon](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/a5b964/32.png) [@rsaccon](https://www.ruby-forum.com/u/rsaccon)\
**Post date:** [March 30, 2015, 12:25pm UTC](https://www.ruby-forum.com/t/e-commerce-con-carrello-temporizzato/234768/20 "2015-03-30T12:25:47Z")

</div>

Aggiungere un controllo sincrono durante le show/update del cart  
indispensabile per mantenere consistenza nella base dati.

I worker Sidekiq o il job cron con whenever servono solo per ricordarsi  
di  
tenere il database pulito, non per mantenerlo consistente durante le  
request dei client.  
On Mar 30, 2015 11:29 AM, “Maurizio De Santis”  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
wrote:

> Non mi sembra un gran problema, a meno che non sia una gara di  
> carrelli a cronometro, immagino tu parli di tempi trascurabili  
> nell’ordine del secondo.

Prendiamo il caso in cui worker sia occupato nel momento in cui deve  
partire il job che svuota il carrello, ed il worker ci mette 5 secondi a  
finire il job che sta facendo: in questo caso ti troveresti il job del  
cart  
spostato 5 secondi pi avanti. 5 come 15 come boh, dipende da quanto ci  
mette il worker a finire la queue precedente al job del cart.

Non so per questo caso quanto facilmente si verifichi nella vita vera,  
immagino dipenda dalla situazione dei jobs.

–

Maurizio De Santis

Il giorno 30 marzo 2015 10:02, Roberto S.  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
ha scritto:

> unica cosa il cronjob dovrebbe partire ogni 15 min, rischio di

* * *

Ml mailing list  
[removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
[http://lists.ruby-it.org/mailman/listinfo/ml](http://lists.ruby-it.org/mailman/listinfo/ml)
