Merge master into develop

omega_client/communication/omega_connection.py

@@ -10,8 +10,6 @@
 
 from omega_client.communication.request_sender import RequestSender
 from omega_client.communication.response_receiver import ResponseReceiver
-from omega_client.communication.single_client_request_sender import \
-    SingleClientRequestSender
 from omega_client.messaging.common_types import AccountBalancesReport, \
     AccountCredentials, AccountDataReport, AccountInfo, \
     AuthorizationRefresh, ExchangePropertiesReport, \
@@ -211,6 +209,19 @@ def logoff(self, request_header: RequestHeader):
         """
         return self._request_sender.logoff(request_header=request_header)
 
+    def send_test_message(self, request_header: RequestHeader,
+                          test_message: str):
+        """
+       Sends a test message to Omega for checking connectivity.  Client id
+       and sender_comp_id won't be checked although they are required,
+       so fake ids can be sent.
+       :param request_header: Header parameter object for requests.
+       :param test_message: (str) Test message.
+       :return: (capnp._DynamicStructBuilder) test_message capnp object.
+       """
+        return self._request_sender.send_test_message(
+            request_header=request_header, test_message=test_message)
+
     def send_heartbeat(self, request_header: RequestHeader):
         """
         Sends a heartbeat to Omega for maintaining and verifying connection.
@@ -460,9 +471,11 @@ def request_authorization_refresh(self,
         )
 
 
-def configure_default_omega_connection(omega_endpoint: str,
-                                     omega_server_key: str,
-                                     response_handler: ResponseHandler):
+def configure_default_omega_connection(
+        zmq_context: zmq.Context,
+        omega_endpoint: str,
+        omega_server_key: str,
+        response_handler: ResponseHandler):
     """
     Set up a TesConnection that comes with request_sender and response_receiver.
     :param omega_endpoint: (str) The zmq endpoint to connect to Omega.
@@ -472,55 +485,18 @@ def configure_default_omega_connection(omega_endpoint: str,
         message.
     :return: omega_connection, request_sender, response_receiver
     """
-    ZMQ_CONTEXT = zmq.Context.instance()
-    request_sender = RequestSender(ZMQ_CONTEXT,
-                                   REQUEST_SENDER_ENDPOINT)
-    response_receiver = ResponseReceiver(ZMQ_CONTEXT,
-                                         RESPONSE_RECEIVER_ENDPOINT,
-                                         response_handler)
-    omega_connection = OmegaConnection(ZMQ_CONTEXT,
-                                       omega_endpoint,
-                                       REQUEST_SENDER_ENDPOINT,
-                                       RESPONSE_RECEIVER_ENDPOINT,
-                                       request_sender,
-                                       response_receiver,
-                                       server_zmq_encryption_key=omega_server_key)
-    return omega_connection, request_sender, response_receiver
-
-
-def configure_single_client_omega_connection(omega_endpoint: str,
-                                           omega_server_key: str,
-                                           client_id: int,
-                                           sender_comp_id: str,
-                                           response_handler: ResponseHandler):
-    """
-    Set up a TesConnection that comes with request_sender and
-    response_receiver.  Sets the default client_id and sender_comp_id for the
-    request sender.
-    Note that each machine should be assigned a unique sender_comp_id even
-    when the client_id is the same.
-    :param omega_endpoint: (str) The zmq endpoint to connect to Omega.
-    :param omega_server_key: (str) The public key of the Omega server.
-    :param client_id: (int) The client id assigned by Fund3.
-    :param sender_comp_id: (str) str representation of a unique Python uuid.
-    :param response_handler: (ResponseHandler) The handler object that will
-        be called in a callback function when omega_connection receives a
-        message.
-    :return: omega_connection, request_sender, response_receiver
-    """
-    ZMQ_CONTEXT = zmq.Context.instance()
-    request_sender = SingleClientRequestSender(ZMQ_CONTEXT,
-                                               REQUEST_SENDER_ENDPOINT,
-                                               client_id,
-                                               sender_comp_id)
-    response_receiver = ResponseReceiver(ZMQ_CONTEXT,
-                                         RESPONSE_RECEIVER_ENDPOINT,
-                                         response_handler)
-    omega_connection = OmegaConnection(ZMQ_CONTEXT,
-                                       omega_endpoint,
-                                       REQUEST_SENDER_ENDPOINT,
-                                       RESPONSE_RECEIVER_ENDPOINT,
-                                       request_sender,
-                                       response_receiver,
-                                       server_zmq_encryption_key=omega_server_key)
-    return omega_connection, request_sender, response_receiver
+    request_sender = RequestSender(zmq_context=zmq_context,
+                                   zmq_endpoint=REQUEST_SENDER_ENDPOINT)
+    response_receiver = ResponseReceiver(
+        zmq_context=zmq_context,
+        zmq_endpoint=RESPONSE_RECEIVER_ENDPOINT,
+        response_handler=response_handler)
+    omega_connection = OmegaConnection(
+        zmq_context=zmq_context,
+        omega_endpoint=omega_endpoint,
+        request_sender_endpoint=REQUEST_SENDER_ENDPOINT,
+        response_receiver_endpoint=RESPONSE_RECEIVER_ENDPOINT,
+        request_sender=request_sender,
+        response_receiver=response_receiver,
+        server_zmq_encryption_key=omega_server_key)
+    return omega_connection

omega_client/communication/request_sender.py

@@ -9,18 +9,18 @@
 
 from omega_client.fpg.fpg_lib import create_SOR_order, FPGAuth
 from omega_client.messaging.common_types import AccountBalancesReport, \
-    AccountCredentials, AccountInfo, AuthorizationGrant, AuthorizationRefresh, \
+    AccountCredentials, AccountInfo, AuthorizationRefresh, \
     CompletedOrdersReport, ExchangePropertiesReport, \
     ExecutionReport, OpenPositionsReport, Order, OrderInfo, \
     OrderType, RequestHeader, TimeInForce, WorkingOrdersReport, Batch, OPO, OCO
 from omega_client.messaging.message_factory import cancel_all_orders_capnp, \
     cancel_order_capnp, heartbeat_capnp, logoff_capnp, logon_capnp, \
-    place_order_capnp, replace_order_capnp, request_account_balances_capnp, \
-    request_account_data_capnp, request_auth_refresh_capnp, \
-    request_completed_orders_capnp, request_exchange_properties_capnp, \
-    request_open_positions_capnp, request_order_status_capnp, \
-    request_server_time_capnp, request_working_orders_capnp, \
-    place_contingent_order_capnp
+    omega_test_message_capnp, place_order_capnp, replace_order_capnp, \
+    request_account_balances_capnp, request_account_data_capnp, \
+    request_auth_refresh_capnp, request_completed_orders_capnp, \
+    request_exchange_properties_capnp, request_open_positions_capnp, \
+    request_order_status_capnp, request_server_time_capnp, \
+    request_working_orders_capnp, place_contingent_order_capnp
 
 logger = logging.getLogger(__name__)
 
@@ -57,7 +57,7 @@ def __init__(self,
                  zmq_endpoint: str,
                  outgoing_message_queue: Queue = None,
                  queue_polling_timeout_seconds: int = 1,
-                 name: str='TesRequestSender'):
+                 name: str='OmegaRequestSender'):
         assert zmq_context
         assert zmq_endpoint
 
@@ -168,6 +168,13 @@ def send_heartbeat(self, request_header: RequestHeader):
         self._queue_message(omega_message)
         return body
 
+    def send_test_message(self, request_header: RequestHeader,
+                          test_message: str):
+        omega_message, body = omega_test_message_capnp(
+            request_header=request_header, test_message=test_message)
+        self._queue_message(omega_message)
+        return body
+
     def request_server_time(self, request_header: RequestHeader):
         """
         Request Omega server time for syncing client and server timestamps.

omega_client/communication/response_receiver.py

@@ -147,6 +147,6 @@ def _handle_binary_omega_message(self, binary_msg: bytes):
             response = trade_message.type.response
             response_type = response.body.which()
             self._handle_response(response_type, response)
-        except (Exception, TypeError) as e:
+        except TypeError as e:
             logger.error('Exception in decoding message' + repr(e),
                          extra={'exception': repr(e)})