def __init__(self, link, speed):
"""
:param link: :class:`~snakemq.link.Link`
:param speed: maximum speed in bytes per second (for individual connection)
"""
self.link = link
# XXX BAD HACK - this naive implementation needs 2 rounds
self.speed = speed * 2
# pass on unused Link object callbacks
self.on_connect = link.on_connect
self.on_disconnect = link.on_disconnect
self.on_recv = link.on_recv
# bridge callbacks
self.on_ready_to_send = Callback()
self.on_loop_pass = Callback()
# hooks for throttling
self.link.on_connect.add(self._on_connect)
self.link.on_disconnect.add(self._on_disconnect)
self.link.on_ready_to_send.add(self._on_ready_to_send)
self.link.on_loop_pass.add(self._on_loop_pass)
#: data buffers {conn_id: ConnectionInfo}
self.connections = {}
#: set of connections waiting for throttle release
self.stopped = set()
def __init__(self, storage):
"""
:param storage: None or persistent storage
"""
assert (storage is None) or isinstance(storage, QueuesStorageBase)
self.storage = storage
self.queues = {} #: name:Queue
self.log = logging.getLogger("snakemq.queuesmanager")
if storage:
self.load_from_storage()
self.log.debug("queues in storage: %i" % len(self.queues))
self.on_item_drop = Callback() #: ``func(queue_name, item_uuid)``
def __init__(self):
self.log = logging.getLogger("snakemq.link")
self.reconnect_interval = RECONNECT_INTERVAL #: in seconds
self.recv_block_size = RECV_BLOCK_SIZE
#{ callbacks
self.on_connect = Callback() #: ``func(conn_id)``
self.on_disconnect = Callback() #: ``func(conn_id)``
#: ``func(conn_id, data)``
self.on_recv = Callback()
#: ``func(conn_id, last_send_size)``, last send was successful
self.on_ready_to_send = Callback()
#: ``func()``, called after poll is processed
self.on_loop_pass = Callback()
#}
self._do_loop = False #: False breaks the loop
self._new_conn_id = 0 #: counter for conn id generator
self.poller = poll()
self._poll_bell = Bell()
self.log.debug("poll bell %r" % self._poll_bell)
self.poller.register(self._poll_bell.r, select.EPOLLIN) # read part
self._sock_by_fd = {}
self._sock_by_conn = {}
self._listen_socks = {} #: address:sock
self._listen_socks_filenos = set()
self._connectors = {} #: address:sock
self._socks_waiting_to_connect = set()
self._plannned_connections = [] #: (when, address)
self._reconnect_intervals = {} #: address:interval
self._in_ssl_handshake = set() #: set of LinkSocket
def __init__(self, link):
"""
:param link: :class:`~snakemq.link.Link`
"""
self.link = link
self.log = logging.getLogger("snakemq.packeter")
#{ callbacks
self.on_connect = Callback() #: ``func(conn_id)``
self.on_disconnect = Callback() #: ``func(conn_id)``
self.on_packet_recv = Callback() #: ``func(conn_id, packet)``
#: ``func(conn_id, packet_id)``, just a signal when a packet was fully sent
self.on_packet_sent = Callback()
self.on_error = Callback() #: ``func(conn_id, exception)``
#}
self._connections = {} # conn_id:ConnectionInfo
self._last_packet_id = 0
self.link.on_connect.add(self._on_connect)
self.link.on_disconnect.add(self._on_disconnect)
self.link.on_recv.add(self._on_recv)
self.link.on_ready_to_send.add(self._on_ready_to_send)
def __init__(self, identifier, domain, packeter, queues_storage=None):
"""
:param identifier: peer identifier
:param domain: currently unused
:param packeter: :class:`~snakemq.packeter.Packeter`
:param queues_storage: :class:`~snakemq.storage.QueuesStorageBase`
"""
self.identifier = identifier[:MAX_IDENT_LENGTH]
self.domain = domain
self.packeter = packeter
self.queues_manager = QueuesManager(queues_storage)
self.log = logging.getLogger("snakemq.messaging")
#: time to ping, in seconds (None = no keepalive)
self.keepalive_interval = None
self.keepalive_wait = 0.5 #: wait for pong, in seconds
#{ callbacks
self.on_error = Callback() #: ``func(conn_id, exception)``
self.on_message_recv = Callback() #: ``func(conn_id, ident, message)``
self.on_message_sent = Callback() #: ``func(conn_id, idemt, message_uuid)``
self.on_connect = Callback() #: ``func(conn_id, ident)``
self.on_disconnect = Callback() #: ``func(conn_id, ident)``
#}
self._ident_by_conn = {}
self._conn_by_ident = {}
self._keepalive = {} #: conn_id:[last_recv, last_ping]
self._message_by_packet = {} #: packet id: message uuid
packeter.link.on_loop_pass.add(self._on_link_loop_pass)
packeter.on_connect.add(self._on_connect)
packeter.on_disconnect.add(self._on_disconnect)
packeter.on_packet_recv.add(self._on_packet_recv)
packeter.on_packet_sent.add(self._on_packet_sent)
self._lock = threading.Lock()