'received 1001 (going away); then sent 1001 (going away)'

[tsunamilx]

Using the futures kline socket, I am getting the following error recently, and it does not reconnect:
{'e': 'error', 'type': 'ConnectionClosedOK', 'm': 'received 1001 (going away); then sent 1001 (going away)'}

This happened before but it was like one time a year, but now it happens every couple of days.

Maybe something changed from binance side, but can we fix the reconnect problem?

[carlosmiei]

@tsunamilx Thanks for reporting it, we will take a look cc\ @pcriadoperez

[pcriadoperez]

hi @tsunamilx ,

I tried to reproduce with some scripts, and on my side it's seems to be reconnecting succesfully. Do you have any logs or a way I could try to reproduce it?

Script 1

import asyncio
import logging
import subprocess
import time
from binance import AsyncClient, BinanceSocketManager
from binance.ws.reconnecting_websocket import ReconnectingWebsocket

logging.basicConfig(level=logging.DEBUG)

# Explicitly set the log level for the binance package
logging.getLogger("binance").setLevel(logging.DEBUG)

logger = logging.getLogger(__name__)


async def simulate_network_disconnect():
    """Simulate network disconnect by temporarily disabling network interface"""
    logger.info("=== SIMULATING NETWORK DISCONNECT ===")
    try:
        # Get the active network interface
        result = subprocess.run(["route", "get", "default"], 
                              capture_output=True, text=True, check=True)
        interface = None
        for line in result.stdout.split('\n'):
            if 'interface:' in line:
                interface = line.split(':')[1].strip()
                break
        
        if not interface:
            logger.error("Could not determine network interface")
            return False
            
        logger.info(f"Temporarily disabling network interface: {interface}")
        
        # Disable the network interface
        subprocess.run(["sudo", "ifconfig", interface, "down"], check=True)
        
        # Wait for disconnect to take effect
        logger.info("Network interface disabled - waiting 10 seconds...")
        await asyncio.sleep(10)
        
        # Re-enable the network interface
        logger.info(f"Re-enabling network interface: {interface}")
        subprocess.run(["sudo", "ifconfig", interface, "up"], check=True)
        
        # Wait a bit for network to come back up
        await asyncio.sleep(3)
        logger.info("Network interface restored")
        
    except Exception as e:
        logger.error(f"Network interface manipulation failed: {e}")
        logger.info("This method requires sudo privileges")
        return False
    
    return True


async def main():
    client = await AsyncClient.create()
    bm = BinanceSocketManager(client)

    # Test futures kline socket to reproduce the 1001 reconnection issue
    async with bm.multiplex_socket(["btcusdt@kline_1s"]) as tscm:
        logger.info("Futures kline websocket started")
        count = 0
        while True:
            try:
                logger.info("Awaiting message...")
                t = await tscm.recv()
                logger.info("Message received")
                count += 1
                
                # Simulate realistic network disconnect after receiving some messages
                if count == 5:
                    logger.info("Triggering network disconnect simulation...")
                    # Run network disconnect simulation in background
                    asyncio.create_task(simulate_network_disconnect())
                
                print(f"Message {count}: {t}")
                
            except Exception as e:
                logger.error(f"Error occurred: {e}")
                logger.error(f"Error type: {type(e)}")
                # Check if we get the ConnectionClosedOK error
                if "ConnectionClosedOK" in str(e) or "1001" in str(e):
                    logger.error("Got the 1001 'going away' error - this should trigger reconnection")
                    logger.error("Waiting to see if websocket reconnects automatically...")
                    await asyncio.sleep(5)  # Wait to see if reconnection happens
                else:
                    raise e

    await client.close_connection()


if __name__ == "__main__":
    asyncio.run(main())

Script 2

import asyncio
import logging
from binance import AsyncClient, BinanceSocketManager
from binance.ws.reconnecting_websocket import ReconnectingWebsocket

logging.basicConfig(level=logging.DEBUG)

# Explicitly set the log level for the binance package
logging.getLogger("binance").setLevel(logging.DEBUG)

logger = logging.getLogger(__name__)


async def main():
    # Set MAX_RECONNECTS to 0 to simulate permanent disconnect
    ReconnectingWebsocket.MAX_RECONNECTS = 3

    client = await AsyncClient.create()
    bm = BinanceSocketManager(client)

    async with bm.multiplex_socket(["btcusdt@kline_1s"]) as tscm:
        logger.info("Websocket started")
        count = 0
        while True:
            logger.info("Awaiting message...")
            t = await tscm.recv()
            logger.info("Message received")
            count += 1
            try:
                if count == 5:
                    logger.info("Simulating connection drop (code 1001)")
                    await tscm.ws.close(code=1001, reason="going away")
                print(t["data"])
            except KeyError as e:
                logger.warning(f"Error: {e} with data {t}")
            logger.info("Loop continues")

    await client.close_connection()


if __name__ == "__main__":
    asyncio.run(main())

[tsunamilx]

@pcriadoperez thanks for the scripts, however I think the problem is from the socket server side.
Your scripts are trying to simulate the disconnection from the client side, it produces ConnectionClosedError and it can reconnect without problem.
The error I got is ConnectionClosedOK, I think it treats this as normal, and it falls into broad exception check in your read loop, which stops the loop right after that.

I made a minimum example trying to produce this from server side:

import asyncio
import json
import logging

from websockets.asyncio.server import serve
from binance.ws.reconnecting_websocket import ReconnectingWebsocket

logging.basicConfig(level=logging.DEBUG)


async def ws_handler(ws):
    # simulate some normal messages
    for i in range(3):
        await ws.send(json.dumps({'cnt': i}))
        await asyncio.sleep(0.1)

    # then close it, this should produce ConnectionClosedOK with 1001 going away message
    await ws.close(code=1001, reason='going away')


async def main():
    server = await serve(ws_handler, '127.0.0.1', 8766)
    print('server started on ws://127.0.0.1:8766')

    rs = ReconnectingWebsocket('ws://127.0.0.1:8766/', prefix='', path='')
    async with rs:
        while True:
            try:
                res = await asyncio.wait_for(rs.recv(), timeout=5)
                print('recv', res)
            except asyncio.TimeoutError:
                print('recv timeout')

    server.close()
    await server.wait_closed()


asyncio.run(main())

Hope it helps.