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()