--
You received this message because you are subscribed to the Google Groups "Django users" group.
To view this discussion on the web visit https://groups.google.com/d/msg/django-users/-/jc20eqhcl8oJ.
To post to this group, send email to django...@googlegroups.com.
To unsubscribe from this group, send email to django-users...@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/django-users?hl=en.
Did you check out django-celery yet?
To unsubscribe from this group, send email to django-users+unsubscribe@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msg/django-users/-/9Xk3RQ-y6pgJ.
To unsubscribe from this group, send email to django-users...@googlegroups.com.
> I don't know if this is what I want, but I believe that there is
> another way around:
> when user B calls foo view, it will render to him a page with a JS(I
> don't know JS either, so correct me if I'm talking nonsense) that say
> its "Loading..."
> And after the do_someting_slow() finished running if will change the
> content of the page to whatever the result of "do_something_slow" was.
I think this is what the "Asynchronous" in AJAX stands for.
http://en.wikipedia.org/wiki/Ajax_%28programming%29
https://code.djangoproject.com/wiki/AJAX
Marc
That is not related to initial problem (long running tasks on server).
Even you can use AJAX calls to perfrom something asyncronously, it still
requires open connection to server. If you have tasks that runs long,
let's say 20 minutes your AJAX call will definitely be terminated (timed
out). So that is not a right solution.
Using AJAX to query long running status makes a lot of sense though.
--
Jani Tiainen
the idea is to use a Queue:
you have a separate process (typically implemented in a manage
command) that stays running, and waits for messages in the queue.
when the web app wants to do some slow processing, writes any needed
parameters to the queue and returns with a 'wait...' message
the background process receives the queue item and does the process
without tying up the web response.
the first implementation almost everybody does is called "Ghetto
queues", it consist of writing the parameters to the database in a
'todo' table, and a cron process that periodically checks these todo's
and processes them. it works, but falls down at a certain load.
after that, you need a real queue manager; either RabbitMQ, Redis
Queues, or a lot of other options.
Celery is a python package that allows you to simply add a '@task'
decorator to any function; so that when you call them, they're not
executed, but instead the argument list is pushed to a queue. it also
creates an admin command that does the queue reading and actually
calls the functions with the arguments it founds on there.
--
Javier
I don't have any easily shareable code, but the basic principle is like this:
Django request comes in
View wants to handle some code in the background
View creates task object, with an id
View renders page, includes task id
Rendered page polls the web server with the id, waiting for the task to finish
Webserver returns data associated with id when task is complete
Javascript inserts data into the page
Meanwhile..
When the task is created, a message is sent to the message broker.
There are several backend task processors attached to the message
broker, and the message is delivered to one of them.
The task processor runs the delayed task, and once complete returns the data.
Cheers
Tom
Your solution will work perfectly in single process environment (For
example with manage.py runserver )
But when you put your app behind webserver you usually invoke several
processes. For example if you're using single round-robin loadbalancing
over 5 different Django instances.
What would happen if Django instances are restarted after n cycles (like
our wsgi django instances are restarted after 1000 requests). Can you
guarantee that your thread survives?
If you do "massive" scaling: what happens if you have multiple servers,
how can you guarantee that consecutive requests from single user goes to
same server and same process?
That is why there exists things like django-celery and rabbitmq (message
broker). How they work is already explained to you.
20.3.2012 16:52, Arruda kirjoitti:
> Thanks every one, I've manage to work this around.
> The solution might not be the best, but it's working:
> In the view I call the *do_something_slow()* in a new thread, and in the
> end of it(after the role process is done) it change the model of a class
> to add the feedback.
> While the thread is running it renders the template to the user(with a
> *"Loading..."* message).
> Then I've made a *ajax_get_feed_back() *view to get this feedback.
>
> In the template, I made a simple JS that every second tries to get the
> feedback via ajax.
> And if it gets the feedback it stops requesting it.
> =)
>
> But I still wanted to know how to use the celery in this case =/
> But got very lost in that, does any one have a example(code) of
> something similar to do with it?
> In the docs I only found examples of process that are kind of tasks...
> to run every hour, or things like that.
>
> Em segunda-feira, 19 de mar�o de 2012 15h18min09s UTC-3, Arruda escreveu:
>
> *(I've created a topic like this a few minutes ago, but was using
> the old google groups, and now it's broken. So I created a new one
> using the new google groups).*
> Hi, I'll try to explain the best I can my problem, and I don't know if
> what I'm trying to archive is the best way to get where I want, but
> here is it:
> I want that a specific view to run in a new thread, ex:
> *def foo(request):
> do_something_slow()
> return httpResponse*
>
> But I DON'T want that a new thread is run inside the view, the view it
> self should be runned in another thread, ex:
> *
> def foo(request):
> t = thread(target=do_something_slow()....)
> t.daemon = True
> t.start()
>
> return httpResponse
> *
> This way when a user A access any page the site will load, even if a
> user B is accessing the 'foo' view.
> But the B user when access the view 'foo' will load it just a if if
> was a normal view( will be slow and will render the response just
> after do_something_slow() finished running).
>
> I don't know if this is what I want, but I believe that there is
> another way around:
> when user B calls foo view, it will render to him a page with a JS(I
> don't know JS either, so correct me if I'm talking nonsense) that say
> its "Loading..."
> And after the do_someting_slow() finished running if will change the
> content of the page to whatever the result of "do_something_slow" was.
>
> Thanks for the attention.
>
> --
> You received this message because you are subscribed to the Google
> Groups "Django users" group.
> To view this discussion on the web visit
> https://groups.google.com/d/msg/django-users/-/ST6KqE0uPqsJ.