Lähe põhisisu juurde
Eesti— Vali keel
Menüü

WebSocketi seansside haldamine

Õppetund 11 / 14 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Valda seansi elutsüklit
  2. Seansi elutsükkel
  3. Automaatne uuesti ühendumine
  4. Seansi kehtivusaja haldamine
  5. Seansipuhver
  6. Jälgitavad mõõdikud
  7. Peamised punktid

Uuendatud 3. novembril 2026, tuginedes xAI Text to Speech lehele, mis mainib 600-sekundilist „seansi luba“ ja ühendust ilma aegumiseta. Allpool kirjeldatud uuendusstrateegia on ettevaatusabinõu. Allikas: Text to Speech.

Valda seansi elutsüklit

Tootmiskeskkonnas eristab töökindlat toodet prototüübist just robustne WebSocketi seansihaldus. TTS-seanssidel on konkreetsed piirangud (kehtivusaeg, samaaegsuse limiidid), mida sinu rakendus peab korrektselt käsitlema.

Seansi elutsükkel

TTS-i WebSocketi seanss läbib järgmist tsüklit:

  1. Avamine: ühendumine aadressiga wss://api.x.ai/v1/tts koos parameetritega
  2. Aktiivne: sõnumite text.delta/audio.delta vahetamine
  3. Normaalne sulgemine: klient või server sulgeb ühenduse
  4. Ootamatu sulgemine: viga, hooldustööd või dokumentatsioonis mainitud 600-sekundilise seansi loa lõppemine

Sulgemise tuvastamine

Server võib ühenduse igal ajal sulgeda (sisemine viga, hooldustööd, seansi loa lõppemine). Sinu rakendus peaks alati käsitlema sulgemissündmust:

async def managed_session(api_key, language="en", voice="eve"):
    uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
    headers = {"Authorization": f"Bearer {api_key}"}

    try:
        async with websockets.connect(uri, additional_headers=headers) as ws:
            yield ws
    except websockets.ConnectionClosed as e:
        print(f"Connection closed: code={e.code}, reason={e.reason}")
    except websockets.ConnectionClosedError:
        print("Connection lost unexpectedly")

Automaatne uuesti ühendumine

Pikaajaliste rakenduste jaoks rakenda uuesti ühendumine eksponentsiaalse taganemisega (exponential backoff):

import asyncio
import random

class TTSSessionManager:
    def __init__(self, api_key, language="en", voice="eve"):
        self.api_key = api_key
        self.language = language
        self.voice = voice
        self.ws = None
        self.max_retries = 5

    async def connect(self):
        uri = f"wss://api.x.ai/v1/tts?language={self.language}&voice={self.voice}"
        headers = {"Authorization": f"Bearer {self.api_key}"}

        for attempt in range(self.max_retries):
            try:
                self.ws = await websockets.connect(uri, additional_headers=headers)
                print(f"Connected (attempt {attempt + 1})")
                return
            except Exception as e:
                wait = min(2 ** attempt + random.random(), 30)
                print(f"Connection failed: {e}. Retrying in {wait:.1f}s")
                await asyncio.sleep(wait)

        raise ConnectionError("Could not connect after 5 attempts")

    async def ensure_connected(self):
        if self.ws is None or self.ws.closed:
            await self.connect()

    async def synthesize(self, text):
        await self.ensure_connected()

        try:
            await self.ws.send(json.dumps({
                "type": "text.delta",
                "delta": text
            }))
            await self.ws.send(json.dumps({"type": "text.done"}))

            audio_chunks = []
            async for msg in self.ws:
                data = json.loads(msg)
                if data["type"] == "audio.delta":
                    audio_chunks.append(base64.b64decode(data["delta"]))
                elif data["type"] == "audio.done":
                    break
                elif data["type"] == "error":
                    raise Exception(data["message"])

            return b"".join(audio_chunks)

        except websockets.ConnectionClosed:
            # Ühendu uuesti ja proovi uuesti
            await self.connect()
            return await self.synthesize(text)

Seansi kehtivusaja haldamine

xAI Text to Speech leht mainib 600-sekundilist „seansi luba“, täpsustamata, millal see algab või mis juhtub selle lõppedes, ning eraldi väidab, et ühendusel puudub aegumine. Ettevaatlikum lähenemine on lugeda aega alates ühenduse loomisest ja uuendada seanss enne selle punkti saavutamist:

import time

class TTLAwareSession:
    TTL = 600  # sekundit
    REFRESH_MARGIN = 60  # ühendu uuesti 60 s enne aegumist

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... ühendus ...
        self.connected_at = time.time()

    def should_refresh(self):
        if self.connected_at is None:
            return True
        elapsed = time.time() - self.connected_at
        return elapsed >= (self.TTL - self.REFRESH_MARGIN)

    async def synthesize(self, text):
        if self.should_refresh():
            await self.connect()  # Uus seanss
        # ... saada tekst ...

Uuesti ühendumine 60 sekundit enne aegumist hoiab ära katkestuse sünteesi keskel.

Seansipuhver

Suure liiklusega rakenduste jaoks hoia alles taaskasutatavate seansside puhvrit:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Maks 50 meeskonna kohta
        self.available = asyncio.Queue()
        self.active_count = 0

    async def acquire(self):
        if not self.available.empty():
            session = await self.available.get()
            if not session.should_refresh():
                return session

        if self.active_count < self.pool_size:
            session = TTSSessionManager(self.api_key)
            await session.connect()
            self.active_count += 1
            return session

        # Oota, kuni seanss vabaneb
        return await self.available.get()

    async def release(self, session):
        await self.available.put(session)

Hoia puhvri suurus murdosana 50-seansilisest limiidist, et jätta varu rakenduse muudele teenustele.

Jälgitavad mõõdikud

Seansside tervise säilitamiseks tootmiskeskkonnas jälgi järgmist:

  • Aktiivsete seansside arv: ei tohi ületada 50
  • Uuesti ühendumise määr: kõrge määr viitab võrgu- või kehtivusajaprobleemile
  • Esimese audio.delta latentsus: mõõdab teenuse reageerimisvõimet
  • WebSocketi vead: ebanormaalsed sulgemiskoodid (1006, 1011)
class MetricsCollector:
    def __init__(self):
        self.connections = 0
        self.reconnections = 0
        self.errors = 0
        self.first_audio_latencies = []

    def record_connection(self):
        self.connections += 1

    def record_reconnection(self):
        self.reconnections += 1

    def record_first_audio(self, latency_ms):
        self.first_audio_latencies.append(latency_ms)

Peamised punktid

  • Dokumentatsioon mainib 600-sekundilist seansi luba: ohutuse mõttes loe seda alates ühenduse loomisest
  • Rakenda automaatne uuesti ühendumine eksponentsiaalse taganemisega
  • Uuenda seanss enne selle punkti saavutamist (60-sekundilise varuga)
  • Kasuta suure liiklusega rakenduste jaoks seansipuhvrit
  • Püsi 50 samaaegse seansi piiris meeskonna kohta
  • Jälgi tootmiskeskkonnas ühenduse mõõdikuid