subscription and websocket

[Tradetechnique]

Hi,

I use the script in Python for subscribe to aCardWasUpdated.
But after some times of execution (about 1 or 2 hours), I only receive ping from the websocket. There are no data.

How can I restart the connexion when I have 2 ping in a row ?

Thanks

[juliusdanek]

You need to reset the connection! Sorare cannot keep the connections open for that long.

[Tradetechnique]

ok that's what I thought.
but how I can do that with the websocket python script ?

I did like that but I'm not sure is the best way :

add an infinite loop :

while True:
        try:
            long_connection()
        except Exception as e:
            # gc.collect()
            print("Websocket connection Error  : {0}".format(e))                    
        print("Reconnecting websocket after 3 sec")
        time.sleep(3)

and when there is multiple pings in a row, I close de connection :
ws.close()

what did you think ? Is there a way to directly reset the connection?
many thanks

[juliusdanek]

We are using a cron job that resets the connection every 1 hour. To make it more robust, you can have several connections open at the same time.

[Tradetechnique]

I can't because when I have several connections open at the same time, I get this error :
Too many subscriptions from the same user, IP or channel

how can i have several connections ? (I have an API KEY)

[leszekhanusz]

Using the new gqlactioncable package described in PR #261, you can configure a permanent reconnecting session with backoff and jitter.

Something like this:

import asyncio                                                                                                          
import backoff                                                                                                          
import logging                                                                                                          
#logging.basicConfig(level=logging.DEBUG)                                                                               
                                                                                                                        
from gql import Client, gql                                                                                             
from gql.transport.exceptions import TransportQueryError                                                                
                                                                                                                        
from gqlactioncable import ActionCableWebsocketsTransport                                                               
                                                                                                                        
                                                                                                                        
subscription = gql(                                                                                                     
    """                                                                                                                 
    subscription onAnyCardUpdated {                                                                                     
      anyCardWasUpdated {                                                                                                 
        card {
          name
          grade
        }                                                                                                         
      }                                                                                                                 
    }                                                                                                                   
"""                                                                                                                     
)                                                                                                                       
                                                                                                                        
@backoff.on_exception(backoff.expo,                                                                                     
                      Exception,                                                                                        
                      giveup=lambda e: isinstance(e, TransportQueryError))                                              
async def execute_subscription(session):                                                                                
                                                                                                                        
    print ("\n\nStarting new subscription\n\n")                                                                         
                                                                                                                        
    async for result in session.subscribe(subscription):                                                                
        print(result["anyCardWasUpdated"])                                                                                         
                                                                                                                        
async def main():                                                                                                       
                                                                                                                        
    client = Client(                                                                                                    
        transport=ActionCableWebsocketsTransport(                                                                       
            url="wss://ws.sorare.com/cable",                                                                            
            keep_alive_timeout=30,                                                                                      
        )                                                                                                               
    )                                                                                                                   
                                                                                                                        
    session = await client.connect_async(reconnecting=True)                                                             
                                                                                                                        
    task = asyncio.create_task(execute_subscription(session))                                                           
                                                                                                                        
    await task                                                                                                          
                                                                                                                        
asyncio.run(main())

[redox]

^ Thank you for that @leszekhanusz !