WebSocket —
HTTP Upgrade'den Wire Frame'e.

GET /chat HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: http://example.com

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

import hashlib
import base64

# RFC 6455 Section 1.3 — sabit magic UUID
GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

def compute_accept(sec_websocket_key: str) -> str:
    combined = sec_websocket_key + GUID
    sha1_hash = hashlib.sha1(combined.encode("utf-8")).digest()
    return base64.b64encode(sha1_hash).decode("utf-8")

# Örnek: tarayıcının gönderdiği key
key = "dGhlIHNhbXBsZSBub25jZQ=="
accept = compute_accept(key)
print(f"Sec-WebSocket-Accept: {accept}")
# → s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
|I|S|S|S|  (4)  |A|     (7)    |             (16/64)           |
|N|V|V|V|       |S|             |   (if payload len==126/127)   |
| |1|2|3|       |K|             |                               |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - -+
|     Extended payload length continued, if payload len == 127  |
+ - - - - - - - - - - - - - - -+-------------------------------+
|  Masking-key (4 bytes, if MASK=1)                             |
+---------------------------------------------------------------+
|                      Payload Data                             |
+---------------------------------------------------------------+

def apply_mask(payload: bytes, masking_key: bytes) -> bytes:
    """RFC 6455 Section 5.3 — XOR masking/unmasking (aynı işlem)."""
    return bytes(
        b ^ masking_key[i % 4]
        for i, b in enumerate(payload)
    )

# Client "Hello" metnini sunucuya gönderecek
payload  = b"Hello"
mask_key = b"\x37\xfa\x21\x3d"  # rastgele 4 byte

masked   = apply_mask(payload, mask_key)
unmasked = apply_mask(masked, mask_key)   # aynı fonksiyon ile geri al
print(unmasked)  # b'Hello'

import asyncio
import websockets

async def server_with_ping(websocket):
    try:
        async for message in websocket:
            await websocket.send(f"echo: {message}")
    except websockets.ConnectionClosed:
        print("Bağlantı kapandı")

# ping_interval ve ping_timeout websockets.serve() parametresi olarak verilir
async def main():
    async with websockets.serve(
        server_with_ping,
        "0.0.0.0",
        8765,
        ping_interval=30,   # her 30 saniyede ping gönder
        ping_timeout=10,    # 10 saniye içinde pong gelmezse bağlantıyı kes
    ):
        await asyncio.get_event_loop().run_until_complete(asyncio.Future())

asyncio.run(main())

pip install websockets          # en güncel stabil sürüm
python -c "import websockets; print(websockets.__version__)"

import asyncio
import websockets
from websockets.server import WebSocketServerProtocol

async def handler(websocket: WebSocketServerProtocol) -> None:
    # websocket.remote_address → (ip, port) tuple
    # websocket.path          → "/chat" gibi URL path
    # websocket.request_headers → HTTP upgrade header'ları
    remote = websocket.remote_address
    print(f"Yeni bağlantı: {remote[0]}:{remote[1]} — path: {websocket.path}")
    try:
        async for message in websocket:
            print(f"[{remote}] aldı: {message}")
            await websocket.send(f"echo: {message}")
    except websockets.ConnectionClosedOK:
        print(f"[{remote}] normal kapandı")
    except websockets.ConnectionClosedError as e:
        print(f"[{remote}] hata: {e.code} {e.reason}")

import asyncio
import websockets

async def echo(websocket):
    async for message in websocket:
        await websocket.send(message)

async def main():
    async with websockets.serve(echo, "0.0.0.0", 8765) as server:
        print("Echo server başlatıldı → ws://localhost:8765")
        await server.wait_closed()

asyncio.run(main())

import asyncio
import websockets

# Bağlı tüm client'ları takip eden set
CONNECTED: set = set()

async def handler(websocket):
    CONNECTED.add(websocket)
    try:
        async for message in websocket:
            # Gönderici hariç herkese ilet
            recipients = CONNECTED - {websocket}
            if recipients:
                await asyncio.gather(
                    *[r.send(message) for r in recipients]
                )
    finally:
        CONNECTED.discard(websocket)

async def main():
    async with websockets.serve(handler, "0.0.0.0", 8765):
        await asyncio.Future()  # sonsuza kadar çalış

asyncio.run(main())

async def handler(websocket):
    path = websocket.path
    if path == "/chat":
        await chat_handler(websocket)
    elif path == "/metrics":
        await metrics_handler(websocket)
    else:
        await websocket.close(1008, "Unknown endpoint")

import asyncio
import websockets

async def main():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as ws:
        await ws.send("Merhaba sunucu!")
        response = await ws.recv()
        print(f"Yanıt: {response}")
        # context manager bloğu sonunda bağlantı kapatılır

asyncio.run(main())

import asyncio
import websockets

async def listen():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as ws:
        # async for: sunucu close frame gönderene kadar döngü sürer
        async for message in ws:
            print(f"Gelen: {message}")
            # binary veriyse: isinstance(message, bytes)

asyncio.run(listen())

import asyncio
import websockets

async def check_connection():
    async with websockets.connect("ws://localhost:8765") as ws:
        # Manuel ping — latency ölçümü
        latency = await ws.ping()
        print(f"Round-trip latency: {latency:.3f}s")

        # Bağlantı durumu
        print(f"Kapalı mı: {ws.closed}")          # False
        print(f"Close code: {ws.close_code}")    # None (henüz kapalı değil)

        await ws.send("test")
        msg = await ws.recv()

    # Context manager'dan çıkıldıktan sonra
    print(f"Close code: {ws.close_code}")   # 1000

asyncio.run(check_connection())

// Komut mesajı
{
  "type": "command",
  "payload": { "action": "start", "target": "motor_1" }
}

// Sensör verisi
{
  "type": "sensor",
  "payload": { "temp": 42.5, "unit": "C", "ts": 1712345678 }
}

// Hata bildirimi
{
  "type": "error",
  "payload": { "code": 404, "message": "Unknown command" }
}

import asyncio
import json
import websockets

async def handle_command(websocket, payload: dict):
    action = payload.get("action")
    target = payload.get("target")
    print(f"Komut: {action} → {target}")
    await websocket.send(json.dumps({
        "type": "ack",
        "payload": {"action": action, "status": "ok"}
    }))

async def handle_subscribe(websocket, payload: dict):
    topic = payload.get("topic", "all")
    print(f"Subscribe: {topic}")
    await websocket.send(json.dumps({
        "type": "subscribed",
        "payload": {"topic": topic}
    }))

# Tip → coroutine eşlemesi
DISPATCH = {
    "command": handle_command,
    "subscribe": handle_subscribe,
}

async def handler(websocket):
    async for raw in websocket:
        try:
            msg = json.loads(raw)
            msg_type = msg.get("type")
            payload  = msg.get("payload", {})
        except json.JSONDecodeError:
            await websocket.send(json.dumps({
                "type": "error",
                "payload": {"message": "Invalid JSON"}
            }))
            continue

        handler_fn = DISPATCH.get(msg_type)
        if handler_fn:
            await handler_fn(websocket, payload)
        else:
            await websocket.send(json.dumps({
                "type": "error",
                "payload": {"message": f"Unknown type: {msg_type}"}
            }))

import struct

# Sensör verisi: 4 byte float (sıcaklık) + 4 byte float (nem) + 8 byte int (timestamp)
packet = struct.pack("!ff q", 42.5, 68.3, 1712345678901)

# Binary websocket mesajı olarak gönder
await websocket.send(packet)

# Alıcı tarafta
raw = await websocket.recv()
if isinstance(raw, bytes):
    temp, humidity, ts = struct.unpack("!ff q", raw)
    print(f"Sıcaklık: {temp:.1f}°C, Nem: {humidity:.1f}%")

import asyncio
import time

async def handler(websocket):
    window_start = time.monotonic()
    msg_count    = 0
    MAX_PER_SEC  = 20

    async for raw in websocket:
        now = time.monotonic()
        if now - window_start >= 1.0:
            window_start = now
            msg_count    = 0
        msg_count += 1
        if msg_count > MAX_PER_SEC:
            await websocket.close(1008, "Rate limit exceeded")
            return
        # normal işleme...

import asyncio
import random
import websockets

URI       = "ws://localhost:8765"
MAX_DELAY = 60.0   # saniye — maksimum bekleme

async def connect_with_backoff():
    attempt = 0
    while True:
        try:
            async with websockets.connect(
                URI,
                open_timeout=10,
                ping_interval=20,
                ping_timeout=10,
            ) as ws:
                attempt = 0  # başarıyla bağlandık, sayacı sıfırla
                print("Bağlandı")
                await on_connected(ws)  # subscribe yenile, işleme başla

        except (
            websockets.ConnectionClosed,
            OSError,
            asyncio.TimeoutError,
        ) as exc:
            delay = min(2 ** attempt + random.uniform(0, 1), MAX_DELAY)
            print(f"Bağlantı kesildi ({exc}). {delay:.1f}s sonra tekrar dene.")
            await asyncio.sleep(delay)
            attempt += 1

async def on_connected(ws):
    # Bağlanıldığında subscribe mesajı gönder
    import json
    await ws.send(json.dumps({"type": "subscribe", "payload": {"topic": "sensors"}}))
    async for msg in ws:
        print(f"Mesaj: {msg}")

asyncio.run(connect_with_backoff())

// Kullanıcı odaya katıldı
{ "type": "join",  "nick": "ahmet", "text": "" }

// Normal mesaj
{ "type": "chat",  "nick": "ahmet", "text": "Merhaba!" }

// Kullanıcı ayrıldı (server üretir)
{ "type": "leave", "nick": "ahmet", "text": "" }

import asyncio
import json
import websockets

# nick → websocket eşlemesi
USERS: dict = {}

async def broadcast(msg: dict, exclude=None):
    """Tüm bağlı kullanıcılara mesaj gönder."""
    data = json.dumps(msg, ensure_ascii=False)
    targets = [ws for ws in USERS.values() if ws is not exclude]
    if targets:
        await asyncio.gather(*[ws.send(data) for ws in targets])

async def handler(websocket):
    nick = None
    try:
        # İlk mesaj: join frame
        raw = await websocket.recv()
        data = json.loads(raw)
        nick = data.get("nick", "anonim").strip()[:20]

        if nick in USERS:
            await websocket.send(json.dumps({
                "type": "error", "nick": "server",
                "text": f"'{nick}' takma adı zaten kullanımda."
            }))
            await websocket.close(1008, "Nick taken")
            return

        USERS[nick] = websocket
        print(f"[+] {nick} katıldı ({len(USERS)} kullanıcı)")
        await broadcast({"type": "join", "nick": nick, "text": ""}, exclude=websocket)
        await websocket.send(json.dumps({
            "type": "info", "nick": "server",
            "text": f"Hoşgeldin {nick}! Odada {len(USERS)} kişi var."
        }))

        async for raw in websocket:
            msg = json.loads(raw)
            if msg.get("type") == "chat":
                text = str(msg.get("text", ""))[:500]
                await broadcast({"type": "chat", "nick": nick, "text": text})

    except (websockets.ConnectionClosed, json.JSONDecodeError):
        pass
    finally:
        if nick and nick in USERS:
            del USERS[nick]
            print(f"[-] {nick} ayrıldı ({len(USERS)} kullanıcı)")
            await broadcast({"type": "leave", "nick": nick, "text": ""})

async def main():
    async with websockets.serve(handler, "0.0.0.0", 8765):
        print("Chat server → ws://localhost:8765")
        await asyncio.Future()

asyncio.run(main())

import asyncio
import json
import sys
import websockets

URI = "ws://localhost:8765"

async def receive_messages(ws):
    async for raw in ws:
        msg = json.loads(raw)
        t, nick, text = msg["type"], msg["nick"], msg.get("text", "")
        if t == "chat":
            print(f"\r[{nick}] {text}")
        elif t == "join":
            print(f"\r*** {nick} odaya katıldı ***")
        elif t == "leave":
            print(f"\r*** {nick} ayrıldı ***")
        elif t in ("info", "error"):
            print(f"\r[server] {text}")

async def send_messages(ws, nick: str):
    loop = asyncio.get_event_loop()
    while True:
        # stdin'i asyncio ile oku (blocking olmadan)
        line = await loop.run_in_executor(None, sys.stdin.readline)
        line = line.rstrip("\n")
        if line.lower() == "/quit":
            await ws.close()
            break
        await ws.send(json.dumps({
            "type": "chat", "nick": nick, "text": line
        }))

async def main():
    nick = input("Nick: ").strip()
    async with websockets.connect(URI) as ws:
        # Join mesajı gönder
        await ws.send(json.dumps({"type": "join", "nick": nick, "text": ""}))
        # Gönderme ve alma'yı eşzamanlı çalıştır
        await asyncio.gather(
            receive_messages(ws),
            send_messages(ws, nick),
        )

asyncio.run(main())

# Terminal 1: server
python chat_server.py

# Terminal 2: birinci client
python chat_client.py
# Nick: ahmet

# Terminal 3: ikinci client
python chat_client.py
# Nick: fatma

# Mesaj gönder:
# ahmet terminali: Merhaba!
# fatma terminali: *** ahmet odaya katıldı *** → [ahmet] Merhaba!

import asyncio
import ssl
import websockets

def create_ssl_context() -> ssl.SSLContext:
    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    ctx.load_cert_chain(
        certfile="/etc/ssl/certs/server.crt",
        keyfile="/etc/ssl/private/server.key",
    )
    return ctx

async def main():
    ssl_ctx = create_ssl_context()
    async with websockets.serve(
        handler, "0.0.0.0", 8443, ssl=ssl_ctx
    ):
        print("TLS chat server → wss://localhost:8443")
        await asyncio.Future()

asyncio.run(main())