def __init__(
self,
from_position: Position = None,
batch_size: int = 100,
resolve_links: bool = True,
require_master: bool = False,
direction: StreamDirection = StreamDirection.Forward,
credentials=None,
conversation_id: UUID = None,
):
Conversation.__init__(self, conversation_id, credentials)
self.batch_size = batch_size
self.has_first_page = False
self.resolve_link_tos = resolve_links
self.require_master = require_master
self.from_position = from_position or Position(0, 0)
self.direction = direction
self._logger = logging.get_named_logger(IterAllEvents)
self.iterator = StreamingIterator(self.batch_size)
if direction == StreamDirection.Forward:
self.command = TcpCommand.ReadAllEventsForward
else:
self.command = TcpCommand.ReadAllEventsBackward
def __init__(
self,
discovery,
dispatcher,
retry_policy=None,
ctrl_queue=None,
connect_timeout=5,
name=None,
loop=None,
):
self.name = name
self.connection_counter = 0
self.dispatcher = dispatcher
self.loop = loop or asyncio.get_event_loop()
self.discovery = discovery
self.connected = Event()
self.disconnected = Event()
self.stopped = Event()
self.ctrl_queue = ctrl_queue or asyncio.Queue(loop=self.loop)
self.log = logging.get_named_logger(Connector)
self._run_loop = asyncio.ensure_future(self._run())
self.heartbeat_failures = 0
self.connect_timeout = connect_timeout
self.active_protocol = None
self.retry_policy = retry_policy or DiscoveryRetryPolicy(
retries_per_node=0)
def __init__(
self,
stream,
start_from=0,
batch_size=100,
credential=None,
conversation_id=None,
):
self.stream = stream
self.iterator = StreamingIterator()
self.conversation_id = conversation_id or uuid4()
self._logger = logging.get_named_logger(CatchupSubscription,
self.conversation_id)
self.from_event = start_from
self.direction = StreamDirection.Forward
self.batch_size = batch_size
self.has_first_page = False
self.require_master = False
self.resolve_link_tos = True
self.credential = credential
self.result = Future()
self.phase = CatchupSubscriptionPhase.READ_HISTORICAL
self.buffer = []
self.subscribe_from = -1
self.next_event_number = self.from_event
self.last_event_number = -1
Conversation.__init__(self, conversation_id, credential)
ReadStreamEventsBehaviour.__init__(self, ReadStreamResult,
proto.ReadStreamEventsCompleted)
def __init__(
self,
stream: str,
from_event: int = None,
batch_size: int = 100,
resolve_links: bool = True,
require_master: bool = False,
direction: StreamDirection = StreamDirection.Forward,
credentials=None,
conversation_id: UUID = None,
):
Conversation.__init__(self, conversation_id, credentials)
ReadStreamEventsBehaviour.__init__(self, ReadStreamResult,
proto.ReadStreamEventsCompleted)
self.batch_size = batch_size
self.has_first_page = False
self.stream = stream
self.resolve_link_tos = resolve_links
self.require_master = require_master
self.direction = direction
self._logger = logging.get_named_logger(IterStreamEvents)
self.iterator = StreamingIterator(self.batch_size)
if direction == StreamDirection.Forward:
self.command = TcpCommand.ReadStreamEventsForward
self.from_event = from_event or 0
else:
self.command = TcpCommand.ReadStreamEventsBackward
self.from_event = from_event or -1
def __init__(
self,
writer: asyncio.StreamWriter,
connection_number: int,
output_queue: asyncio.Queue,
name=None,
):
self._logger = logging.get_named_logger(MessageWriter, name, connection_number)
self.writer = writer
self._queue = output_queue
def __init__(
self,
conversation_id: Optional[UUID] = None,
credential: Optional[Credential] = None,
) -> None:
self.conversation_id = conversation_id or uuid4()
self.result: Future = Future()
self.is_complete = False
self.credential = credential
self._logger = logging.get_named_logger(Conversation)
self.one_way = False
def __init__(
self,
output_queue: asyncio.Queue,
connector: Connector,
response_timeout=10,
heartbeat_period=30,
heartbeat_id=None,
) -> None:
self._output = output_queue
self.heartbeat_id = heartbeat_id or uuid.uuid4()
self._connector = connector
self.response_timeout = response_timeout
self.heartbeat_period = heartbeat_period
self.log = logging.get_named_logger(PaceMaker)
self._fut = None
def __init__(
self,
stream: str,
events: Sequence[NewEvent],
expected_version: Union[ExpectedVersion, int] = ExpectedVersion.Any,
require_master: bool = False,
conversation_id: UUID = None,
credential=None,
loop=None,
):
super().__init__(conversation_id, credential)
self._logger = logging.get_named_logger(WriteEvents)
self.stream = stream
self.require_master = require_master
self.events = events
self.expected_version = expected_version
def __init__(
self,
addr: NodeService,
connection_number: int,
dispatcher: MessageDispatcher,
connector,
loop=None,
):
self._log = logging.get_named_logger(PhotonPumpProtocol, connection_number)
self.transport = None
self.loop = loop or asyncio.get_event_loop()
super().__init__(self.loop)
self.connection_number = connection_number
self.node = addr
self.dispatcher = dispatcher
self.connector = connector
def __init__(
self,
reader: asyncio.StreamReader,
connection_number: int,
queue,
pacemaker: PaceMaker,
name=None,
):
self.header_bytes = array.array("B", [0] * (self.MESSAGE_MIN_SIZE))
self.header_bytes_required = self.MESSAGE_MIN_SIZE
self.queue = queue
self.length = 0
self.message_offset = 0
self.conversation_id = None
self.message_buffer = None
self._logger = logging.get_named_logger(MessageReader, name, connection_number)
self.reader = reader
self.pacemaker = pacemaker
self._trace_enabled = self._logger.getEffectiveLevel() <= logging.TRACE
def __init__(
self,
discovery,
dispatcher,
ctrl_queue=None,
connect_timeout=5,
name=None,
):
self.name = name
self.connection_counter = 0
self.dispatcher = dispatcher
self.discovery = discovery
self.connected = Event()
self.disconnected = Event()
self.stopped = Event()
self.ctrl_queue = ctrl_queue or asyncio.Queue()
self.log = logging.get_named_logger(Connector)
self._run_loop = asyncio.ensure_future(self._run())
self.heartbeat_failures = 0
self.connect_timeout = connect_timeout
self.active_protocol = None
def __init__(self, name=None, loop=None):
self.active_conversations = {}
self._logger = logging.get_named_logger(MessageDispatcher, name)
self.output = None
self._loop = loop or asyncio.get_event_loop()
def __init__(self, name=None):
self.active_conversations = {}
self._logger = logging.get_named_logger(MessageDispatcher, name)
self.output = None
