multi procesos en python

[meneillos]

Buenas a todos:

Necesito desarrollar una aplicacion que, digamos, simule el comportamiento de varios dispositivos hardware (emulados, obviados y simplificados por el software) que se ejecuten en la misma maquina (pero suponiendo siempre que es una simulacion de varios dispositivos independientes, cada uno en su maquina).
El caso es que estos dispositivos deben comunicarse entre sí mediante sockets, y la verdad es que estoy intentando darle el enfoque arquitectónico para ver cómo habria de ser, así por encima la aplicacion.

Yo habia pensado hacer una clase Dispositivo y luego, cada vez que se llame a un constructor de dispositivo, hacerlo en un thread distinto, para que digamos emule un comportamiento independiente de los dispositivos, pero es que ahora que caigo los threads no son independientes...yo lo intenté sin hilos, pero claro, al ejecutar el metodo socket.accept() pues hay una espera bloqueante, con lo cual no me vale (aunque me valdría si esta espera bloqueante se produjese en un dispositivo y al bloquearse saltase automaticamente al siguiente)

¿Se le ocurre a alguien una idea más o menos así por encima de cómo habria de ser la aplicacion?

Espero vuestras respuestas.
Un saludo y muchisimas gracias por adelantado

[meneillos]

Pongo un ejemplo:

Código python:

import socket
import threading
class MiThread(threading.Thread):
    def run(self):
        printf("Ejecutando")
    def transmitir(self):
            #datos en crudo, no hacemos procesamiento de datos ni nada: todo se envia a todos
            if not (s == None):
                i = 0
                while i <= numclientes:
                    sc.send(self.aceleracion.encode())
                    sc.send(self.aceleracion.encode())
                    sc.send(self.aceleracion.encode())
                    
    def __init__(self,direccion,velocidad,aceleracion):
        threading.Thread.__init__(self)
        
        self.direccion = direccion
        self.velocidad = velocidad
        self.aceleracion = aceleracion
        print ("El vehiculo tiene una velocidad de",velocidad, "y una aceleracion de", aceleracion,"siguiendo la direccion", direccion)
        s = socket.socket()
        puerto = 50005
        puertoNuevo = puerto + 1
        s.bind(('localhost',puertoNuevo))
        s.listen(3) #lo dejamos en 3 de momento, puesto que usaremos 3 objetos
        #El metodo accept bloquea la ejecucion a la espera de conexiones
        #accept devuelve un objeto socket y una tupla Ip y puerto
        #Se necesita hacer forks para los distintos vehiculos, porque el metodo
        print("Conexion inicializada")
        #socket.accept() es BLOQUEANTE)
        sc, addr = s.accept()
        
        
 
vehiculo1 = MiThread("norte",20,0)
vehiculo1.start()
vehiculo2 = MiThread("norte",30,0)
vehiculo2.start()
vehiculo3 = MiThread("sur",60,0)
vehiculo3.start()
 

En este ejemplo que quiero que ese vehiculo pueda escuchar (con el metodo accept() ) pero a la vez pueda yo ejecutar el metodo transmitir (supongo que será con otro hilo, pero la verdad no se muy bien como se hace), y así para los 3 vehiculos
Además, ni siquiera llega a ejecutarse el metodo run(self) donde deberia imprimir por pantalla el "Ejecutando" ese...

[ElJairo]

busca info sobre el modulo asyncore

saludos

[pykiss]

No tengo muy claro que quieres hacer con el ejemplo ese.

Puedes trabajar con sockets en modo no blocante.
Para ello tienes por ejemplo select.poll, pero es de muy bajo nivel.

yo tengo una librería que es pykiss.poll que es lo mismo pero de mayor nivel, te permite asignar callbacks a los eventos de I/O.

Si en vez de threads te animas a probar los procesos, tengo una librería llamada pykiss.fork que permite la comunicación entre procesos mediante eventos/callbacks, de una manera muy sencilla.

Esto sería equivalente a tu ejemplo

Código:

from pykiss import fork


class Vehiculo_Process(fork.Process):
    def main(self):
        printf("Ejecutando")
		self.instance_events['parametros'] = self.parametros
        fork.Process.main(self)

    def transmitir(self):
    		self.send_event(keyword = 'aceleracion', aceleracion = self.aceleracion)

	def parametros(self, evento):
    	self.direccion = evento['direccion']
    	self.velocidad = evento['velocidad']
    	self.aceleracion = evento['aceleracion']
        print ("El vehiculo tiene una velocidad de %s, y una aceleracion de %s, siguiendo la direccion %s"%(self.velocidad, self.aceleracion, self.direccion))


class Vehiculo_Driver(fork.Driver):
	def parametros(self, direccion, velocidad, aceleracion):
		self.send_event(keyword = 'parametros', direccion=direccion, velocidad=velocidad, aceleracion=aceleracion)

def reenviar(event, driver):
	for d in control.drivers:
		if d==driver:
			continue
		d.send_event(**event)

control = fork.Control()
control.events['aceleracion'] = reenviar


 
vehiculo1 = control.fork(Vehiculo_Driver, Vehiculo_Process)
vehiculo1.parametros("norte",20,0)

vehiculo2 = control.fork(Vehiculo_Driver, Vehiculo_Process)
vehiculo2.parametros("norte",30,0)

vehiculo3 = control.fork(Vehiculo_Driver, Vehiculo_Process)
vehiculo3.parametros("sur",60,0)

Pero no veo que haya nadie escuchando por la aceleración que envías, ni nada.
Si pones un ejemplo funcional te lo "convierto" a procesos concurrentes con pykiss