v/examples/veb/websocket/server.v

module main

import os
import veb
import log
import time
import term
import net
import net.http
import net.websocket

const app_port = 8990

fn main() {
	log.use_stdout()
	mut app := &App{
		wss: new_websocker_server()!
	}
	app.mount_static_folder_at(os.resource_abs_path('assets'), '/assets')!
	app.serve_static('/favicon.ico', os.resource_abs_path('assets/favicon.ico'))!
	veb.run[App, Context](mut app, app_port)
}

pub struct Context {
	veb.Context
}

pub struct App {
	veb.StaticHandler
mut:
	wss &websocket.Server
}

pub fn (mut app App) index(mut ctx Context) veb.Result {
	return $veb.html()
}

pub fn (mut app App) ws(mut ctx Context) veb.Result {
	key := ctx.get_header(http.CommonHeader.sec_websocket_key) or { '' }
	if key == '' {
		ctx.error('Invalid websocket handshake. Key is missing.')
		return ctx.redirect('/')
	}
	dump(ctx.req.cookie('token') or { http.Cookie{} }.value)
	wlog('> transferring connection with key: ${key}, to the websocket server ${voidptr(app.wss)} ...')
	ctx.takeover_conn()
	ctx.conn.set_write_timeout(time.infinite)
	ctx.conn.set_read_timeout(time.infinite)
	spawn fn (mut wss websocket.Server, mut connection net.TcpConn, key string) {
		wss.handle_handshake(mut connection, key) or { wlog('handle_handshake error: ${err}') }
		wlog('>> wss.handle_handshake finished, key: ${key}')
	}(mut app.wss, mut ctx.conn, key)
	wlog('> done transferring connection')
	return veb.no_result()
}

fn slog(message string) {
	eprintln(term.colorize(term.bright_yellow, message))
}

fn wlog(message string) {
	eprintln(term.colorize(term.bright_blue, message))
}

fn new_websocker_server() !&websocket.Server {
	mut logger := &log.Log{}
	logger.set_level(.info)
	logger.set_output_stream(os.stderr())
	mut wss := websocket.new_server(.ip, app_port, '', logger: logger)
	wss.set_ping_interval(100)
	wss.on_connect(fn [mut logger] (mut server_client websocket.ServerClient) !bool {
		server_client.client.logger = logger
		slog('wss.on_connect client.id: ${server_client.client.id} | server_client.client_key: ${server_client.client_key}')
		return true
	})!
	wss.on_close(fn (mut client websocket.Client, code int, reason string) ! {
		slog('wss.on_close client.id: ${client.id} | code: ${code}, reason: ${reason}')
	})
	wss.on_message(fn [mut wss] (mut client websocket.Client, msg &websocket.Message) ! {
		slog('wss.on_message client.id: ${client.id} | msg.opcode: ${msg.opcode} | msg.payload: `${msg.payload.bytestr()}`')
		text := '${client.id} says: "${msg.payload.bytestr()}"'
		// client.write_string(text) or { slog('client.write err: ${err}') return err }
		for i, _ in rlock wss.server_state {
			wss.server_state.clients
		} {
			mut c := rlock wss.server_state {
				wss.server_state.clients[i] or { continue }
			}
			if c.client.get_state() == .open {
				c.client.write_string(text) or {
					slog('error while broadcasting to i: ${i}, ${voidptr(c)}, err: ${err}')
					continue
				}
			}
		}
	})

	slog('Websocket Server initialized, wss: ${voidptr(wss)}')
	return wss
}