Exemple #1
0
    def on_open(self, ws):
        #print("### open ###")
        self.logger.info("[Sub][" + str(self.id) + "] Connected to server")
        self.ws = ws
        self.last_receive_time = get_current_timestamp()
        self.state = ConnectionState.CONNECTED
        self.__watch_dog.on_connection_created(self)
        if self.request.is_trading:
            try:
                if self.request.api_version == ApiVersion.VERSION_V1:
                    builder = UrlParamsBuilder()
                    create_signature(self.__api_key, self.__secret_key, "GET",
                                     self.url, builder)
                    builder.put_url("op", "auth")
                    self.send(builder.build_url_to_json())
                elif self.request.api_version == ApiVersion.VERSION_V2:
                    builder = UrlParamsBuilder()
                    create_signature_v2(self.__api_key, self.__secret_key,
                                        "GET", self.url, builder)
                    self.send(builder.build_url_to_json())
                else:
                    self.on_error(
                        "api version for create the signature fill failed")

            except Exception as e:
                self.on_error("Unexpected error when create the signature: " +
                              str(e))
        else:
            if self.request.subscription_handler is not None:
                self.request.subscription_handler(self)
        return
Exemple #2
0
def request_account_list_channel(client_req_id=None):
    channel = dict()
    channel["op"] = "req"
    channel["topic"] = "accounts.list"
    channel["cid"] = str(client_req_id) if client_req_id else str(
        get_current_timestamp())
    return json.dumps(channel)
Exemple #3
0
def account_channel(mode):
    channel = dict()
    channel["op"] = "sub"
    channel["cid"] = str(get_current_timestamp())
    channel["topic"] = "accounts"
    channel["model"] = mode
    return json.dumps(channel)
Exemple #4
0
def request_order_detail_channel(order_id, client_req_id=None):
    channel = dict()
    channel["op"] = "req"
    channel["topic"] = "orders.detail"
    channel["order-id"] = str(order_id)
    channel["cid"] = str(client_req_id) if client_req_id else str(
        get_current_timestamp())
    return json.dumps(channel)
Exemple #5
0
def request_kline_channel(symbol,
                          interval,
                          from_ts_second=None,
                          to_ts_second=None):
    channel = dict()
    channel["req"] = "market." + symbol + ".kline." + interval
    channel["id"] = str(get_current_timestamp())
    if from_ts_second:
        channel["from"] = int(from_ts_second)
    if to_ts_second:
        channel["to"] = int(to_ts_second)
    return json.dumps(channel)
Exemple #6
0
def request_order_list_channel(symbol,
                               account_id,
                               states_str=None,
                               client_req_id=None):
    channel = dict()
    try:
        channel["op"] = "req"
        channel["account-id"] = account_id
        channel["topic"] = "orders.list"
        channel["symbol"] = symbol
        if states_str and len(states_str):
            channel["states"] = str(states_str)
        channel["cid"] = str(client_req_id) if client_req_id else str(
            get_current_timestamp())
    except Exception as e:
        print(e)
    return json.dumps(channel)
def watch_dog_job(*args):
    watch_dog_instance = args[0]
    for connection in watch_dog_instance.connection_list:
        if connection.state == ConnectionState.CONNECTED:
            if watch_dog_instance.is_auto_connect:
                ts = get_current_timestamp() - connection.last_receive_time
                if ts > watch_dog_instance.receive_limit_ms:
                    watch_dog_instance.logger.warning(
                        "[Sub][" + str(connection.id) +
                        "] No response from server")
                    connection.re_connect_in_delay(
                        watch_dog_instance.connection_delay_failure)
        elif connection.in_delay_connection():
            watch_dog_instance.logger.warning("[Sub] call re_connect")
            connection.re_connect()
            pass
        elif connection.state == ConnectionState.CLOSED_ON_ERROR:
            if watch_dog_instance.is_auto_connect:
                connection.re_connect_in_delay(
                    watch_dog_instance.connection_delay_failure)
                pass
Exemple #8
0
def request_trade_statistics_channel(symbol):
    channel = dict()
    channel["req"] = "market." + symbol + ".detail"
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #9
0
def request_mbp_channel(symbol, levels):
    channel = dict()
    channel["req"] = "market.{symbol}.mbp.{levels}".format(symbol=symbol,
                                                           levels=levels)
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #10
0
def request_price_depth_channel(symbol, step_type="step0"):
    channel = dict()
    channel["req"] = "market." + symbol + ".depth." + step_type
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #11
0
def kline_channel(symbol, interval):
    channel = dict()
    channel["sub"] = "market." + symbol + ".kline." + interval
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #12
0
def orders_update_new_channel(symbol):
    channel = dict()
    channel["op"] = "sub"
    channel["cid"] = str(get_current_timestamp())
    channel["topic"] = "orders." + symbol + ".update"
    return json.dumps(channel)
Exemple #13
0
def price_depth_bbo_channel(symbol):
    channel = dict()
    channel["sub"] = "market." + symbol + ".bbo"
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #14
0
def price_depth_channel(symbol, step_type=DepthStep.STEP0):
    channel = dict()
    channel["sub"] = "market." + symbol + ".depth." + step_type
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #15
0
def trade_channel(symbol):
    channel = dict()
    channel["sub"] = "market." + symbol + ".trade.detail"
    channel["id"] = str(get_current_timestamp())
    return json.dumps(channel)
Exemple #16
0
    def on_message(self, message):
        self.last_receive_time = get_current_timestamp()

        if isinstance(message, (str)):
            #print("RX string : ", message)
            json_wrapper = parse_json_from_string(message)
        elif isinstance(message, (bytes)):
            #print("RX bytes: " + gzip.decompress(message).decode("utf-8"))
            json_wrapper = parse_json_from_string(
                gzip.decompress(message).decode("utf-8"))
        else:
            print("RX unknow type : ", type(message))
            return

        if json_wrapper.contain_key(
                "status") and json_wrapper.get_string("status") != "ok":
            error_code = json_wrapper.get_string_or_default(
                "err-code", "Unknown error")
            error_msg = json_wrapper.get_string_or_default(
                "err-msg", "Unknown error")
            self.on_error(error_code + ": " + error_msg)
        elif json_wrapper.contain_key(
                "err-code") and json_wrapper.get_int("err-code") != 0:
            error_code = json_wrapper.get_string_or_default(
                "err-code", "Unknown error")
            error_msg = json_wrapper.get_string_or_default(
                "err-msg", "Unknown error")
            self.on_error(error_code + ": " + error_msg)
        elif json_wrapper.contain_key("op"):
            op = json_wrapper.get_string("op")
            if op == "notify":
                self.__on_receive(json_wrapper)
            elif op == "ping":
                ping_ts = json_wrapper.get_string("ts")
                self.__process_ping_on_trading_line(ping_ts)
            elif op == "auth":
                if self.request.subscription_handler is not None:
                    self.request.subscription_handler(self)
            elif op == "req":
                self.__on_receive(json_wrapper)
        elif json_wrapper.contain_key("action"):  # for V2
            action_name = json_wrapper.get_string("action")
            if action_name == "ping":
                action_data = json_wrapper.get_object("data")
                ping_ts = action_data.get_string("ts")
                self.__process_ping_on_v2_trade(ping_ts)
            elif action_name == "sub":
                action_code = json_wrapper.get_int("code")
                if action_code == 200:
                    logging.info("subscribe ACK received")
                else:
                    logging.error("receive error data : " + message)
            elif action_name == "req":  #
                action_code = json_wrapper.get_int("code")
                if action_code == 200:
                    logging.info("signature ACK received")
                    if self.request.subscription_handler is not None:
                        self.request.subscription_handler(self)
                else:
                    logging.error("receive error data : " + message)
            elif action_name == "push":
                action_data = json_wrapper.get_object("data")
                if action_data:
                    self.__on_receive(json_wrapper)
                else:
                    logging.error("receive error push data : " + message)

        elif json_wrapper.contain_key("ch"):
            self.__on_receive(json_wrapper)
        elif json_wrapper.contain_key("rep"):
            self.__on_receive(json_wrapper)
        elif json_wrapper.contain_key("ping"):
            ping_ts = json_wrapper.get_string("ping")
            self.__process_ping_on_market_line(ping_ts)
        else:
            print("unknown data process, RX: " +
                  gzip.decompress(message).decode("utf-8"))