From 7f3531077d2dc48797c0fcdef6e8c6a3d19a575f Mon Sep 17 00:00:00 2001 From: Delyan Angelov Date: Sun, 15 Jan 2023 14:48:52 +0200 Subject: [PATCH] examples: improve the output of the websocket examples --- examples/websocket/client-server/client.v | 24 ++++--- examples/websocket/client-server/server.v | 20 ++++-- examples/websocket/ping.v | 78 ++++++++++++++++++----- 3 files changed, 93 insertions(+), 29 deletions(-) diff --git a/examples/websocket/client-server/client.v b/examples/websocket/client-server/client.v index b952f6c55a..5bedc05fad 100644 --- a/examples/websocket/client-server/client.v +++ b/examples/websocket/client-server/client.v @@ -9,6 +9,11 @@ import term // to all other connected clients fn main() { mut ws := start_client()! + defer { + unsafe { + ws.free() + } + } println(term.green('client ${ws.id} ready')) println('Write message and enter to send...') for { @@ -18,9 +23,9 @@ fn main() { } ws.write_string(line)! } - ws.close(1000, 'normal') or { println(term.red('panicing ${err}')) } - unsafe { - ws.free() + ws.close(1000, 'normal') or { + eprintln(term.red('ws.close err: ${err}')) + exit(1) } } @@ -29,25 +34,28 @@ fn start_client() !&websocket.Client { // mut ws := websocket.new_client('wss://echo.websocket.org:443')? // use on_open_ref if you want to send any reference object ws.on_open(fn (mut ws websocket.Client) ! { - println(term.green('websocket connected to the server and ready to send messages...')) + println(term.green('ws.on_open websocket connected to the server and ready to send messages...')) }) // use on_error_ref if you want to send any reference object ws.on_error(fn (mut ws websocket.Client, err string) ! { - println(term.red('error: ${err}')) + println(term.red('ws.on_error error: ${err}')) }) // use on_close_ref if you want to send any reference object ws.on_close(fn (mut ws websocket.Client, code int, reason string) ! { - println(term.green('the connection to the server successfully closed')) + println(term.green('ws.on_close the connection to the server successfully closed')) }) // on new messages from other clients, display them in blue text ws.on_message(fn (mut ws websocket.Client, msg &websocket.Message) ! { if msg.payload.len > 0 { message := msg.payload.bytestr() - println(term.blue('${message}')) + println(term.blue('ws.on_message `${message}`')) } }) - ws.connect() or { println(term.red('error on connect: ${err}')) } + ws.connect() or { + eprintln(term.red('ws.connect error: ${err}')) + return err + } spawn ws.listen() // or { println(term.red('error on listen $err')) } return ws diff --git a/examples/websocket/client-server/server.v b/examples/websocket/client-server/server.v index 013b10bdd7..6e6df5618b 100644 --- a/examples/websocket/client-server/server.v +++ b/examples/websocket/client-server/server.v @@ -3,17 +3,28 @@ module main import net.websocket import term +fn slog(message string) { + eprintln(term.colorize(term.bright_yellow, message)) +} + // this server accepts client connections and broadcast all messages to other connected clients fn main() { - println('press ctrl-c to quit...') + eprintln('press ctrl-c to quit...') start_server()! } fn start_server() ! { + slog('start_server') mut s := websocket.new_server(.ip6, 30000, '') + defer { + unsafe { + s.free() + } + } // Make that in execution test time give time to execute at least one time s.ping_interval = 100 s.on_connect(fn (mut s websocket.ServerClient) !bool { + slog('s.on_connect') // Here you can look att the client info and accept or not accept // just returning a true/false if s.resource_name != '/' { @@ -24,6 +35,7 @@ fn start_server() ! { // on_message_ref, broadcast all incoming messages to all clients except the one sent it s.on_message_ref(fn (mut ws websocket.Client, msg &websocket.Message, mut m websocket.Server) ! { + slog('s.on_message_ref') // for _, cli in m.clients { for i, _ in m.clients { mut c := m.clients[i] @@ -34,10 +46,10 @@ fn start_server() ! { }, s) s.on_close(fn (mut ws websocket.Client, code int, reason string) ! { + slog('s.on_close') println(term.green('client (${ws.id}) closed connection')) }) + s.listen() or { println(term.red('error on server listen: ${err}')) } - unsafe { - s.free() - } + slog('s.listen done') } diff --git a/examples/websocket/ping.v b/examples/websocket/ping.v index 2a1b1f61a5..19871e2e72 100644 --- a/examples/websocket/ping.v +++ b/examples/websocket/ping.v @@ -1,6 +1,7 @@ module main import time +import term import net.websocket fn main() { @@ -9,13 +10,31 @@ fn main() { start_client()! } +fn slog(message string) { + eprintln(term.colorize(term.bright_yellow, message)) +} + +fn clog(message string) { + eprintln(term.colorize(term.cyan, message)) +} + +fn wlog(message string) { + eprintln(term.colorize(term.bright_blue, message)) +} + // start_server starts the websocket server, it receives messages // and send it back to the client that sent it fn start_server() ! { mut s := websocket.new_server(.ip6, 30000, '') + defer { + unsafe { + s.free() + } + } // Make that in execution test time give time to execute at least one time s.ping_interval = 100 s.on_connect(fn (mut s websocket.ServerClient) !bool { + slog('ws.on_connect, s.client_key: ${s.client_key}') // Here you can look att the client info and accept or not accept // just returning a true/false if s.resource_name != '/' { @@ -24,60 +43,85 @@ fn start_server() ! { return true })! s.on_message(fn (mut ws websocket.Client, msg &websocket.Message) ! { - ws.write(msg.payload, msg.opcode) or { panic(err) } + slog('s.on_message msg.opcode: ${msg.opcode} | msg.payload: ${msg.payload}') + ws.write(msg.payload, msg.opcode) or { + eprintln('ws.write err: ${err}') + return err + } }) s.on_close(fn (mut ws websocket.Client, code int, reason string) ! { + slog('s.on_close code: ${code}, reason: ${reason}') // println('client ($ws.id) closed connection') }) - s.listen() or { println('error on server listen: ${err}') } - unsafe { - s.free() + s.listen() or { + slog('s.listen err: ${err}') + return err } + slog('s.listen finished') } // start_client starts the websocket client, it writes a message to // the server and prints all the messages received fn start_client() ! { mut ws := websocket.new_client('ws://localhost:30000')! + defer { + unsafe { + ws.free() + } + } // mut ws := websocket.new_client('wss://echo.websocket.org:443')? // use on_open_ref if you want to send any reference object ws.on_open(fn (mut ws websocket.Client) ! { - println('open!') + clog('ws.on_open') }) // use on_error_ref if you want to send any reference object ws.on_error(fn (mut ws websocket.Client, err string) ! { - println('error: ${err}') + clog('ws.on_error error: ${err}') }) // use on_close_ref if you want to send any reference object ws.on_close(fn (mut ws websocket.Client, code int, reason string) ! { - println('closed') + clog('ws.on_close') }) // use on_message_ref if you want to send any reference object ws.on_message(fn (mut ws websocket.Client, msg &websocket.Message) ! { if msg.payload.len > 0 { message := msg.payload.bytestr() - println('client got type: ${msg.opcode} payload:\n${message}') + clog('ws.on_message client got type: ${msg.opcode} payload: `${message}`') } }) // you can add any pointer reference to use in callback // t := TestRef{count: 10} // ws.on_message_ref(fn (mut ws websocket.Client, msg &websocket.Message, r &SomeRef) ? { - // // println('type: $msg.opcode payload:\n$msg.payload ref: $r') + // // eprintln('type: $msg.opcode payload:\n$msg.payload ref: $r') // }, &r) - ws.connect() or { println('error on connect: ${err}') } - spawn write_echo(mut ws) // or { println('error on write_echo $err') } - ws.listen() or { println('error on listen ${err}') } - unsafe { - ws.free() + ws.connect() or { + clog('ws.connect err: ${err}') + return err } + clog('ws.connect succeeded') + spawn write_echo(mut ws) // or { println('error on write_echo $err') } + ws.listen() or { + clog('ws.listen err: ${err}') + return err + } + clog('ws.listen finished') } fn write_echo(mut ws websocket.Client) ! { + wlog('write_echo, start') message := 'echo this' - for i := 0; i <= 10; i++ { + for i := 0; i <= 5; i++ { // Server will send pings every 30 seconds - ws.write_string(message) or { println('panicing writing ${err}') } + wlog('write_echo, writing message: `${message}` ...') + ws.write_string(message) or { + wlog('write_echo, ws.write_string err: ${err}') + return err + } time.sleep(100 * time.millisecond) } - ws.close(1000, 'normal') or { println('panicing ${err}') } + ws.close(1000, 'normal') or { + wlog('write_echo, close err: ${err}') + return err + } + wlog('write_echo, done') }