def __init__(self, url):
self._url = url
self._send_queue = Queue.Queue()
self._recv_queue = Queue.Queue()
self._futures = FutureCollection()
self._channel = None
self._stub = None
self._handle = None
def send_generator():
disconnect = False
while not disconnect:
message = None
while message is None and not disconnect:
try:
message = self._send_queue.get(True, 1)
if message.message_type == 'system/disconnect':
disconnect = True
except Queue.Empty:
message = None
yield validator_pb2.MessageList(messages=[message])
if disconnect:
break
self._send_generator = send_generator()
def __init__(self, url):
self._url = url
self._futures = FutureCollection()
self._event = Event()
self._event.set()
self._send_recieve_thread = _SendReceiveThread(url,
futures=self._futures,
ready_event=self._event)
self._send_recieve_thread.daemon = True
self._send_recieve_thread.start()
class Stream(object):
def __init__(self, url):
self._url = url
self._futures = FutureCollection()
self._send_recieve_thread = _SendReceiveThread(url, self._futures)
self._send_recieve_thread.daemon = True
self._send_recieve_thread.start()
def send(self, message_type, content):
message = validator_pb2.Message(
message_type=message_type,
correlation_id=_generate_id(),
content=content)
future = Future(message.correlation_id)
self._futures.put(future)
self._send_recieve_thread.put_message(message)
return future
def send_back(self, message_type, correlation_id, content):
"""
Return a response to a message.
:param message_type: validator_pb2.Message.MessageType enum value
:param correlation_id: a random str internal to the validator
:param content: protobuf bytes
"""
message = validator_pb2.Message(
message_type=message_type,
correlation_id=correlation_id,
content=content)
self._send_recieve_thread.put_message(message)
def receive(self):
"""
Used for receiving messages that are not responses
"""
return self._send_recieve_thread.get_message()
def close(self):
self._send_recieve_thread.shutdown()
class Stream(object):
def __init__(self, url):
self._url = url
self._futures = FutureCollection()
self._send_recieve_thread = _SendReceiveThread(url, self._futures)
self._send_recieve_thread.daemon = True
self._send_recieve_thread.start()
def send(self, message_type, content):
message = validator_pb2.Message(message_type=message_type,
correlation_id=_generate_id(),
content=content)
future = Future(message.correlation_id)
self._futures.put(future)
self._send_recieve_thread.put_message(message)
return future
def send_back(self, message_type, correlation_id, content):
"""
Return a response to a message.
:param message_type: one of the strs on MessageType
:param correlation_id: a random str internal to the validator
:param content: protobuf bytes
"""
message = validator_pb2.Message(message_type=message_type,
correlation_id=correlation_id,
content=content)
self._send_recieve_thread.put_message(message)
def receive(self):
"""
Used for receiving messages that are not responses
"""
return self._send_recieve_thread.get_message()
def close(self):
self._send_recieve_thread.shutdown()
def __init__(self, url):
self._url = url
self._futures = FutureCollection()
self._send_recieve_thread = _SendReceiveThread(url, self._futures)
self._send_recieve_thread.daemon = True
self._send_recieve_thread.start()
class Stream(object):
def __init__(self, url):
self._url = url
self._futures = FutureCollection()
self._event = Event()
self._event.set()
self._send_recieve_thread = _SendReceiveThread(url,
futures=self._futures,
ready_event=self._event)
self._send_recieve_thread.daemon = True
self._send_recieve_thread.start()
@property
def url(self):
""" Get the url of the Stream object.
"""
return self._url
def send(self, message_type, content):
"""Send a message to the validator
:param: message_type(validator_pb2.Message.MessageType)
:param: content(bytes)
:return: (future.Future)
:raises: (ValidatorConnectionError)
"""
if not self._event.is_set():
raise ValidatorConnectionError()
message = validator_pb2.Message(message_type=message_type,
correlation_id=_generate_id(),
content=content)
future = Future(message.correlation_id)
self._futures.put(future)
self._send_recieve_thread.put_message(message)
return future
def send_back(self, message_type, correlation_id, content):
"""
Return a response to a message.
:param message_type: validator_pb2.Message.MessageType enum value
:param correlation_id: a random str internal to the validator
:param content: protobuf bytes
:raises (ValidatorConnectionError):
"""
if not self._event.is_set():
raise ValidatorConnectionError()
message = validator_pb2.Message(message_type=message_type,
correlation_id=correlation_id,
content=content)
self._send_recieve_thread.put_message(message)
def receive(self):
"""
Receive messages that are not responses
:return: concurrent.futures.Future
"""
return self._send_recieve_thread.get_message()
def wait_for_ready(self):
"""Blocks until the background thread has recovered
from a disconnect with the validator.
"""
self._event.wait()
def is_ready(self):
"""Whether the background thread has recovered from
a disconnect with the validator
:return: (bool) whether the background thread is ready
"""
return self._event.is_set()
def close(self):
self._send_recieve_thread.shutdown()
def __init__(self, url):
self._url = url
self._futures = FutureCollection()
self._send_recieve_thread = _SendReceiveThread(url, self._futures)
self._send_recieve_thread.daemon = True
self._send_recieve_thread.start()
class Stream(object):
def __init__(self, url):
self._url = url
self._send_queue = Queue.Queue()
self._recv_queue = Queue.Queue()
self._futures = FutureCollection()
self._channel = None
self._stub = None
self._handle = None
def send_generator():
disconnect = False
while not disconnect:
message = None
while message is None and not disconnect:
try:
message = self._send_queue.get(True, 1)
if message.message_type == 'system/disconnect':
disconnect = True
except Queue.Empty:
message = None
yield validator_pb2.MessageList(messages=[message])
if disconnect:
break
self._send_generator = send_generator()
def connect(self):
self._channel = grpc.insecure_channel(self._url)
self._stub = validator_pb2.ValidatorStub(self._channel)
self._handle = self._stub.Connect(self._send_generator)
def done_callback(call):
if call.code() != grpc.StatusCode.OK:
print "ERROR: Connect() failed with status code: {}: {}".\
format(str(call.code()), call.details())
self._handle.add_done_callback(done_callback)
recv_thread = RecvThread(self._handle, self._futures, self._recv_queue)
recv_thread.start()
def send(self, message_type, content):
message = validator_pb2.Message(message_type=message_type,
correlation_id=_generate_id(),
content=content)
future = Future(message.correlation_id)
self._futures.put(future)
self._send_queue.put(message)
return future
def send_back(self, message_type, correlation_id, content):
message = validator_pb2.Message(message_type=message_type,
correlation_id=correlation_id,
content=content)
self._send_queue.put(message)
def receive(self):
return self._recv_queue.get()
def close(self):
message = validator_pb2.Message(message_type='system/disconnect',
correlation_id=_generate_id(),
content='')
self._send_queue.put(message)
while not self._handle.done():
time.sleep(1)
