class ReceiverGateway(BaseGateway):
def __init__(self, queue, channels=list(), numExtractors=4):
BaseGateway.__init__(self, queue, channels, numExtractors)
self.OnMessageReceived = EventHook()
def addChannel(self, channel):
BaseGateway.addChannel(self, channel)
channel.OnMessageReceived += self._messageReceivedChannel
def _process_queue(self):
while self.state == Startable.RUNNING:
item = self._queue.popleft(timeout=10)
if not item is None:
#TODO: Crear los hilos del demonio con el control de errores
pass
def _messageReceivedChannel(self, sender, args):
self._queue.append(args.message)
def __del__(self):
BaseGateway.__del__(self)
self.OnMessageReceived.clear()
def _invokeOnReceivedMessage(self, message):
args = MessageReceivedArgs(message= message)
self.OnMessageReceived.fire(self, args)
class ReceiverGateway(BaseGateway):
def __init__(self, queue, channels=list(), numExtractors=4):
BaseGateway.__init__(self, queue, channels, numExtractors)
self.OnMessageReceived = EventHook()
def addChannel(self, channel):
BaseGateway.addChannel(self, channel)
channel.OnMessageReceived += self._messageReceivedChannel
def _process_queue(self):
while self.state == Startable.RUNNING:
item = self._queue.popleft(timeout=10)
if not item is None:
#TODO: Crear los hilos del demonio con el control de errores
pass
def _messageReceivedChannel(self, sender, args):
self._queue.append(args.message)
def __del__(self):
BaseGateway.__del__(self)
self.OnMessageReceived.clear()
def _invokeOnReceivedMessage(self, message):
args = MessageReceivedArgs(message=message)
self.OnMessageReceived.fire(self, args)
def __init__(self,
host="",
reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS,
compressor=compressors.DefaultCompressor(),
useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections,
compressor, useAck)
self.OnSendError = EventHook()
self._mutex = threading.Lock()
self.OnMessageSent = EventHook()
def __init__(self, queue, channels=list(), numExtractors=4):
Startable.__init__(self)
self._channels = list()
self._queue = queue
self.OnConnectionError = EventHook()
for channel in channels:
self.addChannel(channel)
self._thExtractors = list()
for count in range(0, numExtractors):
self._thExtractors.append(
threading.Thread(target=self._process_queue))
def __init__(self,
host="",
reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS,
compressor=compressors.DefaultCompressor(),
useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections,
compressor, useAck)
Startable.__init__(self)
self._thReceive = threading.Thread(target=self.__workReceive)
self.OnMessageReceived = EventHook()
self.OnStart += self.__beginReceive
self.OnStopped += self.__endReceive
class StartableStateMachine(StateMachine):
initial_state = 'Stopped'
state('Running', enter='_invokeOnStart')
state('Stopped', enter='_invokeOnStopped')
transition(from_=['Running', 'Stopped'], event='start', to='Running')
transition(from_=['Running', 'Stopped'], event='stop', to='Stopped')
## Crea una isntancia de StartableStateMachine
def __init__(self):
self.OnStart = EventHook()
self.OnStopped = EventHook()
StateMachine.__init__(self)
## Lanza el evento OnStart
def _invokeOnStart(self):
self.OnStart.fire()
## Lanza el evento OnStopped
def _invokeOnStopped(self):
self.OnStopped.fire()
## Destructor
def __del__(self):
self.OnStart.clear()
self.OnStopped.clear()
class StartableStateMachine(StateMachine):
initial_state = 'Stopped'
state('Running', enter='_invokeOnStart')
state('Stopped', enter='_invokeOnStopped')
transition(from_=['Running','Stopped'], event='start', to='Running')
transition(from_=['Running','Stopped'], event='stop', to='Stopped')
## Crea una isntancia de StartableStateMachine
def __init__(self):
self.OnStart = EventHook()
self.OnStopped = EventHook()
StateMachine.__init__(self)
## Lanza el evento OnStart
def _invokeOnStart(self):
self.OnStart.fire()
## Lanza el evento OnStopped
def _invokeOnStopped(self):
self.OnStopped.fire()
## Destructor
def __del__(self):
self.OnStart.clear()
self.OnStopped.clear()
def __init__(self,
host="",
reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=MAX_RECONNECTIONS,
compressor=compressors.DefaultCompressor(),
useAck=False):
self._isConnected = False
self._reconnectionTimer = reconnectionTimer
self._reconnectionNumber = 0
self._maxReconnections = maxReconnections
self.OnConnectionError = EventHook()
self._host = host
self._useAck = useAck
self._compressor = compressor
def __init__(self, host="", reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS, compressor=compressors.DefaultCompressor(), useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections, compressor, useAck)
Startable.__init__(self)
self._thReceive = threading.Thread(target=self.__workReceive)
self.OnMessageReceived = EventHook()
self.OnStart += self.__beginReceive
self.OnStopped += self.__endReceive
def __init__(self, host="", reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=MAX_RECONNECTIONS, compressor=compressors.DefaultCompressor(), useAck=False):
self._isConnected = False
self._reconnectionTimer = reconnectionTimer
self._reconnectionNumber = 0
self._maxReconnections = maxReconnections
self.OnConnectionError = EventHook()
self._host = host
self._useAck = useAck
self._compressor = compressor
def __init__(self, queue, channels=list(), numExtractors=4):
Startable.__init__(self)
self._channels = list()
self._queue = queue
self.OnConnectionError = EventHook()
for channel in channels:
self.addChannel(channel)
self._thExtractors = list()
for count in range(0, numExtractors):
self._thExtractors.append(threading.Thread(target=self._process_queue))
class Startable():
RUNNING = "Running"
STOPPED = "Stopped"
def __init__(self):
self._statemachine = StartableStateMachine()
self.OnStart = EventHook()
self.OnStopped = EventHook()
self._statemachine.OnStart += self._invokeOnStart
self._statemachine.OnStopped += self._invokeOnStopped
## Devuelve el estado acutal del proceso
@property
def state(self):
return self._statemachine.current_state
## Incia el proceso
def start(self):
self._statemachine.start()
## Termina el proceso
def stop(self):
self._statemachine.stop()
## Lanza el evento OnStart
def _invokeOnStart(self):
self.OnStart.fire()
## Lanza el evento OnStopped
def _invokeOnStopped(self):
self.OnStopped.fire()
## Destructor
def __del__(self):
self.OnStart.clear()
self.OnStopped.clear()
class Startable():
RUNNING = "Running"
STOPPED = "Stopped"
def __init__(self):
self._statemachine = StartableStateMachine()
self.OnStart = EventHook()
self.OnStopped = EventHook()
self._statemachine.OnStart += self._invokeOnStart
self._statemachine.OnStopped += self._invokeOnStopped
## Devuelve el estado acutal del proceso
@property
def state(self):
return self._statemachine.current_state
## Incia el proceso
def start(self):
self._statemachine.start()
## Termina el proceso
def stop(self):
self._statemachine.stop()
## Lanza el evento OnStart
def _invokeOnStart(self):
self.OnStart.fire()
## Lanza el evento OnStopped
def _invokeOnStopped(self):
self.OnStopped.fire()
## Destructor
def __del__(self):
self.OnStart.clear()
self.OnStopped.clear()
def __init__(self, queue, channels=list(), numExtractors=4):
BaseGateway.__init__(self, queue, channels, numExtractors)
self.OnMessageReceived = EventHook()
def __init__(self):
self._statemachine = StartableStateMachine()
self.OnStart = EventHook()
self.OnStopped = EventHook()
self._statemachine.OnStart += self._invokeOnStart
self._statemachine.OnStopped += self._invokeOnStopped
class InBoundChannel(Channel, Startable):
## Crea una instancia de InBoundChannel
# @param reconnectionTimer Temporizador de reconexion
# @param maxReconnections Numero maximo de reconexiones
# @param host Nombre del host
def __init__(self,
host="",
reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS,
compressor=compressors.DefaultCompressor(),
useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections,
compressor, useAck)
Startable.__init__(self)
self._thReceive = threading.Thread(target=self.__workReceive)
self.OnMessageReceived = EventHook()
self.OnStart += self.__beginReceive
self.OnStopped += self.__endReceive
## Lanza el evento Message Received
def __invokeOnMessageReceived(self, message):
args = MessageReceivedArgs(message=message)
self.OnMessageReceived.fire(self, args)
del args
## Lanza el inicio de la recepcion de mensajes
def __beginReceive(self):
if not self._isConnected:
self.connect()
self._initializeReceive()
self._thReceive.start()
## Propiedad que indica si el punto de conexion esta recibiendo mensajes
@property
def isRunning(self):
return self.state == Startable.RUNNING
## Metodo del hilo en el que se ejecuta la recepcion de mensajes
def __workReceive(self):
while True:
try:
if self.isRunning:
self._startReceive()
else:
self._stopReceive()
break
except Exception as ex:
# Intentamos reconectar
try:
loggerManager.get_endPoints_logger().error(
"Error en la recepcion de mensajes %s" % ex)
self.close()
self._reconnect()
except ConnectionError:
self.stop()
self._invokeOnConnectionError()
break
## Finaliza la recepcion de mensajes
def __endReceive(self):
self._thReceive.join()
self._terminateReceive()
pass
## Metodo al que las clases hijas deben llamar cuando se recibe un mensaje
def _processMessage(self, message, obj):
try:
msg = self._compressor.decompress(message)
self.__invokeOnMessageReceived(msg)
if self._useAck:
self._sendAck(obj)
except Exception as ex:
loggerManager.get_endPoints_logger().error(
"Error al procesar el mensaje: %s" % ex)
raise ex
## Metodo que se las clases hijas deben sobrescribir para realizar la recepcion
# No se debe dejar bloqueado el hilo
def _startReceive(self):
pass
## Metodo al que se llama para inicializar la recepcion, sobrescribir en caso que sea necesario
def _initializeReceive(self):
pass
## Metodo al que se llama para liberar recursos de la recepcion, sobrescribir en caso que sea necesario
def _terminateReceive(self):
pass
## Metodo para mandar el ack una vez que el mensaje se ha leido
def _sendAck(self, obj):
pass
## Metodo para detener la recepcion de mensajes
def _stopReceive(self):
pass
class Channel:
INFINITE_RECONNECTIONS = -1
MAX_RECONNECTIONS = INFINITE_RECONNECTIONS
## Crea una instancia de un punto de conexion, y estable el temporizador
# de la reconexion
# @param host Nombre del host
# @param reconnectionTimer Temporizador de la reconexion (ReconnectionTimer) por defecto Logaritmico
# @param maxReconnections Numero maximo de reconexiones por defecto 10
# @param useCompression Indica si el punto de conexion usa compresion
def __init__(self,
host="",
reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=MAX_RECONNECTIONS,
compressor=compressors.DefaultCompressor(),
useAck=False):
self._isConnected = False
self._reconnectionTimer = reconnectionTimer
self._reconnectionNumber = 0
self._maxReconnections = maxReconnections
self.OnConnectionError = EventHook()
self._host = host
self._useAck = useAck
self._compressor = compressor
## Establece la conexion con el host, en el caso de no establecerse
# se procede a la reconexion hasta que el temporizador llegue a su limite de intentos
# de reconexion
def connect(self):
try:
self._reconnect()
except ConnectionError:
self._invokeOnConnectionError()
## Indica si el punto de conexion esta conectado con el host
def is_connected(self):
return self._isConnected
## Devuelve el nombre del host del punto de conexion
def getHost(self):
return self._host
## Cierra la conexion con el host
def close(self):
try:
if self._isConnected:
self._close_point()
except:
pass
self._isConnected = False
## Metodo que realiza la conexion fisica con el host
# @exception ConnectException Se lanza en el caso de que no sea posible la conexion
def _connect_point(self):
raise ConnectionError("Error de conexion, clase base")
## Cierra la conexion fisica con el host
def _close_point(self):
raise ConnectionError("Error de conexion, clase base")
## Realiza la reconexion en el caso de que se produca una excepcion
# @exception ConnectException Se lanza en el caso de que se haya llegado al limite de
# intentos de reconexion
def _reconnect(self):
# Si ya esta conectado no reconecta
if self._isConnected:
return
self._reconnectionNumber = 0
self._reconnectionTimer.reset()
self._isConnected = False
while True:
try:
loggerManager.get_endPoints_logger().debug(
"Conectando al host: %s", self._host)
self._connect_point()
break
except ConnectionError as ex:
loggerManager.get_endPoints_logger().error(
"Error al conectar: %s" % ex)
if self._maxReconnections != Channel.INFINITE_RECONNECTIONS and self._reconnectionNumber >= self._maxReconnections:
loggerManager.get_endPoints_logger().error(
"Se ha alcanzado el maximo numero de reconexiones")
raise ConnectionError(
"Se ha alcanzado el maximo numero de reconexiones")
else:
loggerManager.get_endPoints_logger().error(
"Intentado reconectar... %d" %
self._reconnectionNumber)
self._reconnectionNumber += 1
self._reconnectionTimer.wait()
self._isConnected = True
## Lanza el evento OnConnectionError
def _invokeOnConnectionError(self):
args = ConnectionErrorArgs(channel=self,
maxReconnections=self._maxReconnections,
numReconnections=self._reconnectionNumber,
timer=self._reconnectionTimer)
self.OnConnectionError.fire(self, args)
del args
## Destructor, si la conexion esta abierta la cierra y libera todos los handler del
# controlador de eventos
def __del__(self):
if self.is_connected():
self.close()
self.OnConnectionError.clear()
class OutBoundChannel(Channel):
## Crea una instancia de OutBoundChannel
# @param reconnectionTimer Temporizador de reconexion
# @param maxReconnections Numero maximo de reconexiones
# @param host Nombre del host
def __init__(self, host="", reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS, compressor=compressors.DefaultCompressor(), useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections, compressor, useAck)
self.OnSendError = EventHook()
self._mutex = threading.Lock()
self.OnMessageSent = EventHook()
## Lanza el evento
def _invokeOnSendError(self, message):
args = SendErrorArgs(channel=self, message=message)
self.OnSendError.fire(self, args)
del args
## Lanza el evento de mensaje enviado
def _invokeOnMessageSent(self, message):
args = SentMessageArgs(channel=self, message=message)
self.OnMessageSent.fire(self, args)
del args
## Envia un mensaje al punto de conexion
def send(self, message):
ret = True
self._mutex.acquire()
while True:
try:
#loggerManager.get_endPoints_logger().debug("Enviando mensaje %s" % message)
msg = self._compressor.compress(message)
ret = self._send(msg)
if not ret:
ret = self.__checkMessageSent(message)
else:
self._invokeOnMessageSent(message)
del msg
break
except ConnectionError as ex:
loggerManager.get_endPoints_logger().error("Error de conexion al enviar el mensaje %s" % ex)
# Intentamos reconectar
try:
self.close()
self._reconnect()
except ConnectionError as ex2:
loggerManager.get_endPoints_logger().error(
"No se ha podido reconectar al enviar el mensaje %s" % ex2)
self._invokeOnSendError(message)
break
except SendError as ex:
loggerManager.get_endPoints_logger().error("Error de envio %s" % ex)
self._invokeOnSendError(message)
break
except Exception:
raise
self._mutex.release()
return ret
## Envia un mensaje al punto de conexion
# @param message Buffer a enviar
# @exception ConnectionError
def _send(self, message):
raise SendError("Metodo no implementado")
## Espera el acuse de recibo del mensaje enviado
def _waitForAck(self):
return True
## Realiza la comprobacion de que el mensaje a sido enviado y lanza los eventos
def __checkMessageSent(self, message):
if self._useAck:
ret = self._waitForAck()
if ret:
self._invokeOnMessageSent(message)
else:
self._invokeOnSendError(message)
return ret
else:
self._invokeOnMessageSent(message)
return True
def __del__(self):
self.OnMessageSent.clear()
self.OnSendError.clear()
Channel.__del__(self)
class OutBoundChannel(Channel):
## Crea una instancia de OutBoundChannel
# @param reconnectionTimer Temporizador de reconexion
# @param maxReconnections Numero maximo de reconexiones
# @param host Nombre del host
def __init__(self,
host="",
reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS,
compressor=compressors.DefaultCompressor(),
useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections,
compressor, useAck)
self.OnSendError = EventHook()
self._mutex = threading.Lock()
self.OnMessageSent = EventHook()
## Lanza el evento
def _invokeOnSendError(self, message):
args = SendErrorArgs(channel=self, message=message)
self.OnSendError.fire(self, args)
del args
## Lanza el evento de mensaje enviado
def _invokeOnMessageSent(self, message):
args = SentMessageArgs(channel=self, message=message)
self.OnMessageSent.fire(self, args)
del args
## Envia un mensaje al punto de conexion
def send(self, message):
ret = True
self._mutex.acquire()
while True:
try:
#loggerManager.get_endPoints_logger().debug("Enviando mensaje %s" % message)
msg = self._compressor.compress(message)
ret = self._send(msg)
if not ret:
ret = self.__checkMessageSent(message)
else:
self._invokeOnMessageSent(message)
del msg
break
except ConnectionError as ex:
loggerManager.get_endPoints_logger().error(
"Error de conexion al enviar el mensaje %s" % ex)
# Intentamos reconectar
try:
self.close()
self._reconnect()
except ConnectionError as ex2:
loggerManager.get_endPoints_logger().error(
"No se ha podido reconectar al enviar el mensaje %s" %
ex2)
self._invokeOnSendError(message)
break
except SendError as ex:
loggerManager.get_endPoints_logger().error(
"Error de envio %s" % ex)
self._invokeOnSendError(message)
break
except Exception:
raise
self._mutex.release()
return ret
## Envia un mensaje al punto de conexion
# @param message Buffer a enviar
# @exception ConnectionError
def _send(self, message):
raise SendError("Metodo no implementado")
## Espera el acuse de recibo del mensaje enviado
def _waitForAck(self):
return True
## Realiza la comprobacion de que el mensaje a sido enviado y lanza los eventos
def __checkMessageSent(self, message):
if self._useAck:
ret = self._waitForAck()
if ret:
self._invokeOnMessageSent(message)
else:
self._invokeOnSendError(message)
return ret
else:
self._invokeOnMessageSent(message)
return True
def __del__(self):
self.OnMessageSent.clear()
self.OnSendError.clear()
Channel.__del__(self)
class Channel:
INFINITE_RECONNECTIONS = -1
MAX_RECONNECTIONS = INFINITE_RECONNECTIONS
## Crea una instancia de un punto de conexion, y estable el temporizador
# de la reconexion
# @param host Nombre del host
# @param reconnectionTimer Temporizador de la reconexion (ReconnectionTimer) por defecto Logaritmico
# @param maxReconnections Numero maximo de reconexiones por defecto 10
# @param useCompression Indica si el punto de conexion usa compresion
def __init__(self, host="", reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=MAX_RECONNECTIONS, compressor=compressors.DefaultCompressor(), useAck=False):
self._isConnected = False
self._reconnectionTimer = reconnectionTimer
self._reconnectionNumber = 0
self._maxReconnections = maxReconnections
self.OnConnectionError = EventHook()
self._host = host
self._useAck = useAck
self._compressor = compressor
## Establece la conexion con el host, en el caso de no establecerse
# se procede a la reconexion hasta que el temporizador llegue a su limite de intentos
# de reconexion
def connect(self):
try:
self._reconnect()
except ConnectionError:
self._invokeOnConnectionError()
## Indica si el punto de conexion esta conectado con el host
def is_connected(self):
return self._isConnected
## Devuelve el nombre del host del punto de conexion
def getHost(self):
return self._host
## Cierra la conexion con el host
def close(self):
try:
if self._isConnected:
self._close_point()
except:
pass
self._isConnected = False
## Metodo que realiza la conexion fisica con el host
# @exception ConnectException Se lanza en el caso de que no sea posible la conexion
def _connect_point(self):
raise ConnectionError("Error de conexion, clase base")
## Cierra la conexion fisica con el host
def _close_point(self):
raise ConnectionError("Error de conexion, clase base")
## Realiza la reconexion en el caso de que se produca una excepcion
# @exception ConnectException Se lanza en el caso de que se haya llegado al limite de
# intentos de reconexion
def _reconnect(self):
# Si ya esta conectado no reconecta
if self._isConnected:
return
self._reconnectionNumber = 0
self._reconnectionTimer.reset()
self._isConnected = False
while True:
try:
loggerManager.get_endPoints_logger().debug("Conectando al host: %s", self._host)
self._connect_point()
break
except ConnectionError as ex:
loggerManager.get_endPoints_logger().error("Error al conectar: %s" % ex)
if self._maxReconnections != Channel.INFINITE_RECONNECTIONS and self._reconnectionNumber >= self._maxReconnections:
loggerManager.get_endPoints_logger().error("Se ha alcanzado el maximo numero de reconexiones")
raise ConnectionError("Se ha alcanzado el maximo numero de reconexiones")
else:
loggerManager.get_endPoints_logger().error("Intentado reconectar... %d" % self._reconnectionNumber)
self._reconnectionNumber += 1
self._reconnectionTimer.wait()
self._isConnected = True
## Lanza el evento OnConnectionError
def _invokeOnConnectionError(self):
args = ConnectionErrorArgs(channel=self, maxReconnections=self._maxReconnections,
numReconnections=self._reconnectionNumber, timer=self._reconnectionTimer)
self.OnConnectionError.fire(self, args)
del args
## Destructor, si la conexion esta abierta la cierra y libera todos los handler del
# controlador de eventos
def __del__(self):
if self.is_connected():
self.close()
self.OnConnectionError.clear()
def __init__(self):
self._statemachine = StartableStateMachine()
self.OnStart = EventHook()
self.OnStopped = EventHook()
self._statemachine.OnStart += self._invokeOnStart
self._statemachine.OnStopped += self._invokeOnStopped
def __init__(self):
self.OnStart = EventHook()
self.OnStopped = EventHook()
StateMachine.__init__(self)
def __init__(self, queue, channels=list(), numExtractors=4):
BaseGateway.__init__(self, queue, channels, numExtractors)
self.OnMessageReceived = EventHook()
class BaseGateway(Startable):
## Crea una instancia de BasicGateway
# @param channel Canal de comunicacion utilizado por el gateway
def __init__(self, queue, channels=list(), numExtractors=4):
Startable.__init__(self)
self._channels = list()
self._queue = queue
self.OnConnectionError = EventHook()
for channel in channels:
self.addChannel(channel)
self._thExtractors = list()
for count in range(0, numExtractors):
self._thExtractors.append(threading.Thread(target=self._process_queue))
## Añade un nuevo canal al gateway
def addChannel(self, channel):
self._channels.append(channel)
channel.OnConnectionError += self._invokeOnConnectionError
## Realiza la conexion del canal
def connect(self):
for channel in self._channels:
channel.connect()
## Cierra la conexion del canal
def close(self):
for channel in self._channels:
channel.close()
## Indica si el canal esta o no conectado
@property
def is_connected(self):
for channel in self._channels:
if channel.is_connected():
return True
return False
def _invokeOnConnectionError(self, sender, args):
#TODO: Es un error de conexion del canal que hay que tratar ademas de disparar
self.OnConnectionError.fire(self, args)
def _process_queue(self):
pass
def _invokeOnStart(self):
Startable._invokeOnStart(self)
for th in self._thExtractors:
th.start()
def _invokeOnStopped(self):
Startable._invokeOnStopped(self)
for th in self._thExtractors:
th.join()
def __del__(self):
Startable.__del__(self)
for channel in self._channels:
del channel
self.OnConnectionError.clear()
class BaseGateway(Startable):
## Crea una instancia de BasicGateway
# @param channel Canal de comunicacion utilizado por el gateway
def __init__(self, queue, channels=list(), numExtractors=4):
Startable.__init__(self)
self._channels = list()
self._queue = queue
self.OnConnectionError = EventHook()
for channel in channels:
self.addChannel(channel)
self._thExtractors = list()
for count in range(0, numExtractors):
self._thExtractors.append(
threading.Thread(target=self._process_queue))
## Añade un nuevo canal al gateway
def addChannel(self, channel):
self._channels.append(channel)
channel.OnConnectionError += self._invokeOnConnectionError
## Realiza la conexion del canal
def connect(self):
for channel in self._channels:
channel.connect()
## Cierra la conexion del canal
def close(self):
for channel in self._channels:
channel.close()
## Indica si el canal esta o no conectado
@property
def is_connected(self):
for channel in self._channels:
if channel.is_connected():
return True
return False
def _invokeOnConnectionError(self, sender, args):
#TODO: Es un error de conexion del canal que hay que tratar ademas de disparar
self.OnConnectionError.fire(self, args)
def _process_queue(self):
pass
def _invokeOnStart(self):
Startable._invokeOnStart(self)
for th in self._thExtractors:
th.start()
def _invokeOnStopped(self):
Startable._invokeOnStopped(self)
for th in self._thExtractors:
th.join()
def __del__(self):
Startable.__del__(self)
for channel in self._channels:
del channel
self.OnConnectionError.clear()
def __init__(self, host="", reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS, compressor=compressors.DefaultCompressor(), useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections, compressor, useAck)
self.OnSendError = EventHook()
self._mutex = threading.Lock()
self.OnMessageSent = EventHook()
def __init__(self):
self.OnStart = EventHook()
self.OnStopped = EventHook()
StateMachine.__init__(self)
class InBoundChannel(Channel, Startable):
## Crea una instancia de InBoundChannel
# @param reconnectionTimer Temporizador de reconexion
# @param maxReconnections Numero maximo de reconexiones
# @param host Nombre del host
def __init__(self, host="", reconnectionTimer=reconnectiontimers.CreateLogarithmicTimer(),
maxReconnections=Channel.MAX_RECONNECTIONS, compressor=compressors.DefaultCompressor(), useAck=False):
Channel.__init__(self, host, reconnectionTimer, maxReconnections, compressor, useAck)
Startable.__init__(self)
self._thReceive = threading.Thread(target=self.__workReceive)
self.OnMessageReceived = EventHook()
self.OnStart += self.__beginReceive
self.OnStopped += self.__endReceive
## Lanza el evento Message Received
def __invokeOnMessageReceived(self, message):
args = MessageReceivedArgs(message=message)
self.OnMessageReceived.fire(self, args)
del args
## Lanza el inicio de la recepcion de mensajes
def __beginReceive(self):
if not self._isConnected:
self.connect()
self._initializeReceive()
self._thReceive.start()
## Propiedad que indica si el punto de conexion esta recibiendo mensajes
@property
def isRunning(self):
return self.state == Startable.RUNNING
## Metodo del hilo en el que se ejecuta la recepcion de mensajes
def __workReceive(self):
while True:
try:
if self.isRunning:
self._startReceive()
else:
self._stopReceive()
break
except Exception as ex:
# Intentamos reconectar
try:
loggerManager.get_endPoints_logger().error("Error en la recepcion de mensajes %s" % ex)
self.close()
self._reconnect()
except ConnectionError:
self.stop()
self._invokeOnConnectionError()
break
## Finaliza la recepcion de mensajes
def __endReceive(self):
self._thReceive.join()
self._terminateReceive()
pass
## Metodo al que las clases hijas deben llamar cuando se recibe un mensaje
def _processMessage(self, message, obj):
try:
msg = self._compressor.decompress(message)
self.__invokeOnMessageReceived(msg)
if self._useAck:
self._sendAck(obj)
except Exception as ex:
loggerManager.get_endPoints_logger().error("Error al procesar el mensaje: %s" % ex)
raise ex
## Metodo que se las clases hijas deben sobrescribir para realizar la recepcion
# No se debe dejar bloqueado el hilo
def _startReceive(self):
pass
## Metodo al que se llama para inicializar la recepcion, sobrescribir en caso que sea necesario
def _initializeReceive(self):
pass
## Metodo al que se llama para liberar recursos de la recepcion, sobrescribir en caso que sea necesario
def _terminateReceive(self):
pass
## Metodo para mandar el ack una vez que el mensaje se ha leido
def _sendAck(self, obj):
pass
## Metodo para detener la recepcion de mensajes
def _stopReceive(self):
pass
