Hola,
Por lo que necesitas, creo que podrias usar gevent-sockectio [1].
Para ver como funciona mira el código del server [2] y tambien hay un
ejemplo para hacer un chat [3]
En [4] hay un articulo para trabajar con gevent, sockectio y django donde
muestra un código tipo:
from django.http import HttpResponse
buffer = []
def socketio(request):
socketio = request.environ['socketio']
if socketio.on_connect():
socketio.send({'buffer': buffer})
socketio.broadcast({'announcement': socketio.session.session_id + '
connected'})
while True:
message = socketio.recv()
if len(message) == 1:
message = message[0]
message = {'message': [socketio.session.session_id, message]}
buffer.append(message)
if len(buffer) > 15:
del buffer[0]
socketio.broadcast(message)
else:
if not socketio.connected():
socketio.broadcast({'announcement':
socketio.session.session_id + ' disconnected'})
break
return HttpResponse()
Que tambien tiene un bucle infinito leyendo el mensaje desde
socketio.recv(), mas o menos como en tu código
[1] https://bitbucket.org/Jeffrey/gevent-socketio/src
[2]
https://bitbucket.org/Jeffrey/gevent-socketio/src/ed74e0013df2/socketio/server.py
[3]
https://bitbucket.org/Jeffrey/gevent-socketio/src/ed74e0013df2/examples/chat.py
[4]
http://codysoyland.com/2011/feb/6/evented-django-part-one-socketio-and-gevent/
:D
El 15 de agosto de 2012 23:59, Diego Uribe Gamez <
[email protected]> escribió:
> Ok yo entiendo y ya lo mire, Gracias, Se que es fuerte pero quiero
> mantener y adaptar la estructura de eventos en python.
>
> El 15 de agosto de 2012 16:48, Alvaro Manrique
> <[email protected]>escribió:
>
> Buenas Tardes;
>>
>> Perdón si mi respuesta es off-topic pero si te interesa trabajar con
>> javascript y manejar paquetes json para una especie de chat, creo que debes
>> darle un vistazo a node.js, se que es una nueva tecnología pero estuve
>> viendo el manejo de sockets y con unas pocas líneas de código se implementa
>> lo que tu quieres.
>> El 15/08/2012 16:43, "Diego Uribe Gamez" <[email protected]>
>> escribió:
>>
>> mmmm Disculpen que no me hice entender, voy a hablar a nivel
>>> de código y me voy a enfocar en el proyecto que mencione al principio,
>>> la razón de hacerlo de esta manera que la forma en la que funciona y el
>>> problema como la solución para mi proyecto esta en usar jason y Gevent,
>>> porque las consultas van a ser muchas y este sistema de combinado hace que
>>> la pagina chatee con la maquina sin gastar muchos recursos.
>>>
>>> Mi problema es en acondicionar este proyecto a la idea como tal de
>>> chatear con una maquina, me gusta es que tengo mucho del código a la mano y
>>> la idea es adaptarme.
>>>
>>> El código actual:
>>> -----------------------------------------------------------------------
>>> # Datos para la conexion al Socket y la IP que escucharemos
>>> host = '190.145.XXX.XXX'
>>> port = 33XX
>>> buf = 102400
>>> addr = (host, port)
>>> # Creamos el Socket - (INTERNET,UDP)
>>> UDPSock = socket(AF_INET,SOCK_DGRAM)
>>> UDPSock.bind(addr)
>>> # Bucle infinito (PROBLEMA)
>>> while 1:
>>> # recibir data
>>> data,addr = UDPSock.recvfrom(buf)
>>> -----------------------------------------------------------------------
>>> Nota: Resulta que yo estoy usando este código para capturar
>>> la información que me envían a mi ip y puerto, el problema es que estoy
>>> usando un bucle infinito para hacerlo y creo que esta mal, adicional
>>> necesitaba que apenas llegara algun dato poder mostrarselo al usuario en la
>>> pantalla, pensando en una solución me encontré con este proyecto y su demo
>>> que es un chat(en python, gevent, jason y javascript), donde para mi una
>>> solución es poder chatear con la maquina o mejor dicho es que apenas la
>>> maquina se comunique la idea es que el usuario pueda ver la información en
>>> tiempo real en la pagina web sin necesidad de recargar la pagina.
>>>
>>> En el código a continuación yo entiendo muchas cosas pero no estoy
>>> seguro de como adaptar mi código actual a la solución del problema.
>>>
>>> message_new() este se encarga de crear nuevos mensajes para los
>>> navegadores usando create_message y lo retorna con un json_response
>>>
>>> message_updates() dice que si no hay un mensaje en cache o que si el
>>> mensaje del navegador(cursor) es igual al ultimo mensaje toca esperar a un
>>> nuevo mensaje self.new_message_event.wait() para luego actualizar
>>>
>>> Código del Chat:
>>> -----------------------------------------------------------------------
>>> import uuid
>>> import simplejson
>>> from django.shortcuts import render_to_response
>>> from django.template.loader import render_to_string
>>> from django.http import HttpResponse
>>> from gevent.event import Event
>>> import settings
>>>
>>>
>>> class ChatRoom(object):
>>> cache_size = 200
>>>
>>> def __init__(self):
>>> self.cache = []
>>> self.new_message_event = Event()
>>>
>>> def main(self, request):
>>> if self.cache:
>>> request.session['cursor'] = self.cache[-1]['id']
>>> return render_to_response('index.html', {'MEDIA_URL':
>>> settings.MEDIA_URL, 'messages': self.cache})
>>>
>>> def message_new(self, request):
>>> name = request.META.get('REMOTE_ADDR') or 'Anonymous'
>>> forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
>>> if forwarded_for and name == '127.0.0.1':
>>> name = forwarded_for
>>> msg = create_message(name, request.POST['body'])
>>> self.cache.append(msg)
>>> if len(self.cache) > self.cache_size:
>>> self.cache = self.cache[-self.cache_size:]
>>> self.new_message_event.set()
>>> self.new_message_event.clear()
>>> return json_response(msg)
>>>
>>> def message_updates(self, request):
>>> cursor = request.session.get('cursor')
>>> if not self.cache or cursor == self.cache[-1]['id']:
>>> self.new_message_event.wait()
>>> assert cursor != self.cache[-1]['id'], cursor
>>> try:
>>> for index, m in enumerate(self.cache):
>>> if m['id'] == cursor:
>>> return json_response({'messages': self.cache[index +
>>> 1:]})
>>> return json_response({'messages': self.cache})
>>> finally:
>>> if self.cache:
>>> request.session['cursor'] = self.cache[-1]['id']
>>> else:
>>> request.session.pop('cursor', None)
>>>
>>> room = ChatRoom()
>>> main = room.main
>>> message_new = room.message_new
>>> message_updates = room.message_updates
>>>
>>> def create_message(from_, body):
>>> data = {'id': str(uuid.uuid4()), 'from': from_, 'body': body}
>>> data['html'] = render_to_string('message.html',
>>> dictionary={'message': data})
>>> return data
>>>
>>> def json_response(value, **kwargs):
>>> kwargs.setdefault('content_type', 'text/javascript; charset=UTF-8')
>>> return HttpResponse(simplejson.dumps(value), **kwargs)
>>> -----------------------------------------------------------------------
>>>
>>> Esto un poco por encima lo entiendo, lo que no sabría es como adaptar
>>> mi código actual a message_new?
>>>
>>> Espero haberme hecho entender y ver si pueden darme una idea.
>>>
>>> Gracias.
>>>
>>>
>>> El 14 de agosto de 2012 19:20, Olemis Lang <[email protected]> escribió:
>>>
>>>> On 8/14/12, Alexandro Colorado <[email protected]> wrote:
>>>> > Si hay sistemas sobre jabber donde puedes crear un chat de grupo
>>>> estilo IRC
>>>> > donde tus servidores se conecten al irse en linea y esten reportando
>>>> cosas
>>>> > originadas de dbus o eventos de tu servidor web.
>>>> > Lo complicado seria la
>>>> > pre-programacion para que puedas responderles con comandos para
>>>> reiniciar,
>>>> > depurar, o resumir procesos.
>>>> >
>>>> > Estos proyecgtos probablemente ya existen es solo de seguir buscando,
>>>> el
>>>> > detalle es saber que realmente quieres lograr.
>>>> >
>>>>
>>>> a ver a ver ... si están hablando d XMPP algo debería aparecer por aquí
>>>> http://xmpp.org/xmpp-protocols/xmpp-extensions/
>>>>
>>>> > 2012/8/14 Diego Uribe Gamez <[email protected]>
>>>> >
>>>> >> Saludos, comunidad,
>>>> >>
>>>> >> Traigo este tema bastante interesante y es que quiero chatear con una
>>>> >> maquina,
>>>>
>>>> d hecho , si somos más estrictos en realidad *SIEMPRE* las máquinas
>>>> están chateando entre ellas , lo q de vez en cuando nos dejan ver unos
>>>> byte-citos ... ;)
>>>>
>>>> hay muchos ejemplos de bots implementados sobre XMPP . Está Google
>>>> guru , los ex-bots de Google Wave , ...
>>>>
>>>> [...]
>>>>
>>>> --
>>>> Regards,
>>>>
>>>> Olemis.
>>>>
>>>> Blog ES: http://simelo-es.blogspot.com/
>>>> Blog EN: http://simelo-en.blogspot.com/
>>>>
>>>> Featured article:
>>>> _______________________________________________
>>>> Python-es mailing list
>>>> [email protected]
>>>> http://mail.python.org/mailman/listinfo/python-es
>>>> FAQ: http://python-es-faq.wikidot.com/
>>>>
>>>
>>>
>>>
>>> --
>>> *Diego Alonso Uribe Gamez*
>>> ------------------------------
>>>
>>> *Desarrollador web*
>>>
>>> Twitter: @DiegoUG <http://www.twitter.com/DiegoUG>
>>>
>>> Google+: http://gplus.to/diegoug
>>> ------------------------------
>>>
>>>
>>>
>>> _______________________________________________
>>> Python-es mailing list
>>> [email protected]
>>> http://mail.python.org/mailman/listinfo/python-es
>>> FAQ: http://python-es-faq.wikidot.com/
>>>
>>>
>> _______________________________________________
>> Python-es mailing list
>> [email protected]
>> http://mail.python.org/mailman/listinfo/python-es
>> FAQ: http://python-es-faq.wikidot.com/
>>
>>
>
>
> --
> *Diego Alonso Uribe Gamez*
> ------------------------------
>
> *Desarrollador web*
>
> Twitter: @DiegoUG <http://www.twitter.com/DiegoUG>
>
> Google+: http://gplus.to/diegoug
> ------------------------------
>
>
>
> _______________________________________________
> Python-es mailing list
> [email protected]
> http://mail.python.org/mailman/listinfo/python-es
> FAQ: http://python-es-faq.wikidot.com/
>
>
_______________________________________________
Python-es mailing list
[email protected]
http://mail.python.org/mailman/listinfo/python-es
FAQ: http://python-es-faq.wikidot.com/
