mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

vfmt: change all '$expr' to '${expr}' (#16428)

Browse Source
This commit is contained in:
yuyi
2022-11-15 21:53:13 +08:00
committed by GitHub
parent 56239b4a23
commit 017ace6ea7
859 changed files with 7156 additions and 7135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
vlib/net/websocket/events.v
View File

@@ -171,10 +171,12 @@ fn (mut ws Client) send_message_event(msg &Message) {
ws.debug_log('sending on_message event')
for ev_handler in ws.message_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws, msg) or { ws.logger.error('send_message_event error: $err') }
ev_handler.handler(mut ws, msg) or {
ws.logger.error('send_message_event error: ${err}')
}
} else {
ev_handler.handler2(mut ws, msg, ev_handler.ref) or {
ws.logger.error('send_message_event error: $err')
ws.logger.error('send_message_event error: ${err}')
}
}
}
@@ -186,11 +188,11 @@ fn (mut ws Client) send_error_event(error string) {
for ev_handler in ws.error_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws, error) or {
ws.logger.error('send_error_event error: $error, err: $err')
ws.logger.error('send_error_event error: ${error}, err: ${err}')
}
} else {
ev_handler.handler2(mut ws, error, ev_handler.ref) or {
ws.logger.error('send_error_event error: $error, err: $err')
ws.logger.error('send_error_event error: ${error}, err: ${err}')
}
}
}
@@ -202,11 +204,11 @@ fn (mut ws Client) send_close_event(code int, reason string) {
for ev_handler in ws.close_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws, code, reason) or {
ws.logger.error('send_close_event error: $err')
ws.logger.error('send_close_event error: ${err}')
}
} else {
ev_handler.handler2(mut ws, code, reason, ev_handler.ref) or {
ws.logger.error('send_close_event error: $err')
ws.logger.error('send_close_event error: ${err}')
}
}
}
@@ -217,10 +219,10 @@ fn (mut ws Client) send_open_event() {
ws.debug_log('sending on_open event')
for ev_handler in ws.open_callbacks {
if !ev_handler.is_ref {
ev_handler.handler(mut ws) or { ws.logger.error('send_open_event error: $err') }
ev_handler.handler(mut ws) or { ws.logger.error('send_open_event error: ${err}') }
} else {
ev_handler.handler2(mut ws, ev_handler.ref) or {
ws.logger.error('send_open_event error: $err')
ws.logger.error('send_open_event error: ${err}')
}
}
}

26
vlib/net/websocket/handshake.v
View File

@@ -25,7 +25,7 @@ fn (mut ws Client) handshake() ! {
sb.write_string('\r\nSec-WebSocket-Version: 13')
for key in ws.header.keys() {
val := ws.header.custom_values(key).join(',')
sb.write_string('\r\n$key:$val')
sb.write_string('\r\n${key}:${val}')
}
sb.write_string('\r\n\r\n')
handshake := sb.str()
@@ -33,7 +33,7 @@ fn (mut ws Client) handshake() ! {
unsafe { handshake.free() }
}
handshake_bytes := handshake.bytes()
ws.debug_log('sending handshake: $handshake')
ws.debug_log('sending handshake: ${handshake}')
ws.socket_write(handshake_bytes)!
ws.read_handshake(seckey)!
unsafe { handshake_bytes.free() }
@@ -49,18 +49,18 @@ fn (mut s Server) handle_server_handshake(mut c Client) !(string, &ServerClient)
// parse_client_handshake parses result from handshake process
fn (mut s Server) parse_client_handshake(client_handshake string, mut c Client) !(string, &ServerClient) {
s.logger.debug('server-> client handshake:\n$client_handshake')
s.logger.debug('server-> client handshake:\n${client_handshake}')
lines := client_handshake.split_into_lines()
get_tokens := lines[0].split(' ')
if get_tokens.len < 3 {
return error_with_code('unexpected get operation, $get_tokens', 1)
return error_with_code('unexpected get operation, ${get_tokens}', 1)
}
if get_tokens[0].trim_space() != 'GET' {
return error_with_code("unexpected request '${get_tokens[0]}', expected 'GET'",
2)
}
if get_tokens[2].trim_space() != 'HTTP/1.1' {
return error_with_code("unexpected request $get_tokens, expected 'HTTP/1.1'",
return error_with_code("unexpected request ${get_tokens}, expected 'HTTP/1.1'",
3)
}
mut seckey := ''
@@ -80,9 +80,9 @@ fn (mut s Server) parse_client_handshake(client_handshake string, mut c Client)
}
'Sec-WebSocket-Key', 'sec-websocket-key' {
key = keys[1].trim_space()
s.logger.debug('server-> got key: $key')
s.logger.debug('server-> got key: ${key}')
seckey = create_key_challenge_response(key)!
s.logger.debug('server-> challenge: $seckey, response: ${keys[1]}')
s.logger.debug('server-> challenge: ${seckey}, response: ${keys[1]}')
flags << .has_accept
}
else {
@@ -92,9 +92,9 @@ fn (mut s Server) parse_client_handshake(client_handshake string, mut c Client)
unsafe { keys.free() }
}
if flags.len < 3 {
return error_with_code('invalid client handshake, $client_handshake', 4)
return error_with_code('invalid client handshake, ${client_handshake}', 4)
}
server_handshake := 'HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: $seckey\r\n\r\n'
server_handshake := 'HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${seckey}\r\n\r\n'
server_client := &ServerClient{
resource_name: get_tokens[1]
client_key: key
@@ -143,11 +143,11 @@ fn (mut ws Client) read_handshake(seckey string) ! {
// check_handshake_response checks the response from handshake and returns
// the response and secure key provided by the websocket client
fn (mut ws Client) check_handshake_response(handshake_response string, seckey string) ! {
ws.debug_log('handshake response:\n$handshake_response')
ws.debug_log('handshake response:\n${handshake_response}')
lines := handshake_response.split_into_lines()
header := lines[0]
if !header.starts_with('HTTP/1.1 101') && !header.starts_with('HTTP/1.0 101') {
return error_with_code('handshake_handler: invalid HTTP status response code, $header',
return error_with_code('handshake_handler: invalid HTTP status response code, ${header}',
6)
}
for i in 1 .. lines.len {
@@ -163,9 +163,9 @@ fn (mut ws Client) check_handshake_response(handshake_response string, seckey st
ws.flags << .has_connection
}
'Sec-WebSocket-Accept', 'sec-websocket-accept' {
ws.debug_log('seckey: $seckey')
ws.debug_log('seckey: ${seckey}')
challenge := create_key_challenge_response(seckey)!
ws.debug_log('challenge: $challenge, response: ${keys[1]}')
ws.debug_log('challenge: ${challenge}, response: ${keys[1]}')
if keys[1].trim_space() != challenge {
return error_with_code('handshake_handler: Sec-WebSocket-Accept header does not match computed sha1/base64 response.',
7)

2
vlib/net/websocket/io.v
View File

@@ -72,7 +72,7 @@ fn (mut ws Client) shutdown_socket() ! {
// dial_socket connects tcp socket and initializes default configurations
fn (mut ws Client) dial_socket() !&net.TcpConn {
tcp_address := '$ws.uri.hostname:$ws.uri.port'
tcp_address := '${ws.uri.hostname}:${ws.uri.port}'
mut t := net.dial_tcp(tcp_address)!
optval := int(1)
t.sock.set_option_int(.keep_alive, optval)!

8
vlib/net/websocket/message.v
View File

@@ -64,7 +64,7 @@ pub fn (mut ws Client) validate_frame(frame &Frame) ! {
}
}
if frame.fin == false && ws.fragments.len == 0 && frame.opcode == .continuation {
err_msg := 'unexecpected continuation, there are no frames to continue, $frame'
err_msg := 'unexecpected continuation, there are no frames to continue, ${frame}'
ws.close(1002, err_msg)!
return error(err_msg)
}
@@ -111,7 +111,7 @@ fn (mut ws Client) read_payload(frame &Frame) ![]u8 {
// - Future implementation needs to support fail fast utf errors for strict autobahn conformance
fn (mut ws Client) validate_utf_8(opcode OPCode, payload []u8) ! {
if opcode in [.text_frame, .close] && !utf8.validate(payload.data, payload.len) {
ws.logger.error('malformed utf8 payload, payload len: ($payload.len)')
ws.logger.error('malformed utf8 payload, payload len: (${payload.len})')
ws.send_error_event('Recieved malformed utf8.')
ws.close(1007, 'malformed utf8 payload')!
return error('malformed utf8 payload')
@@ -146,8 +146,8 @@ pub fn (mut ws Client) read_next_message() !Message {
}
if ws.fragments.len == 0 {
ws.validate_utf_8(frame.opcode, frame_payload) or {
ws.logger.error('UTF8 validation error: $err, len of payload($frame_payload.len)')
ws.send_error_event('UTF8 validation error: $err, len of payload($frame_payload.len)')
ws.logger.error('UTF8 validation error: ${err}, len of payload(${frame_payload.len})')
ws.send_error_event('UTF8 validation error: ${err}, len of payload(${frame_payload.len})')
return err
}
msg := Message{

6
vlib/net/websocket/tests/autobahn/autobahn_client.v
View File

@@ -5,8 +5,8 @@ import net.websocket
fn main() {
for i in 1 .. 304 {
println('\ncase: $i')
handle_case(i) or { println('error should be ok: $err') }
println('\ncase: ${i}')
handle_case(i) or { println('error should be ok: ${err}') }
}
// update the reports
uri := 'ws://autobahn_server:9001/updateReports?agent=v-client'
@@ -16,7 +16,7 @@ fn main() {
}
fn handle_case(case_nr int) ! {
uri := 'ws://autobahn_server:9001/runCase?case=$case_nr&agent=v-client'
uri := 'ws://autobahn_server:9001/runCase?case=${case_nr}&agent=v-client'
mut ws := websocket.new_client(uri)!
ws.on_message(on_message)
ws.connect()!

6
vlib/net/websocket/tests/autobahn/autobahn_client_wss.v
View File

@@ -5,8 +5,8 @@ import net.websocket
fn main() {
for i in 1 .. 304 {
println('\ncase: $i')
handle_case(i) or { println('error should be ok: $err') }
println('\ncase: ${i}')
handle_case(i) or { println('error should be ok: ${err}') }
}
// update the reports
// uri := 'wss://localhost:9002/updateReports?agent=v-client'
@@ -17,7 +17,7 @@ fn main() {
}
fn handle_case(case_nr int) ! {
uri := 'wss://autobahn_server_wss:9002/runCase?case=$case_nr&agent=v-client'
uri := 'wss://autobahn_server_wss:9002/runCase?case=${case_nr}&agent=v-client'
// uri := 'wss://localhost:9002/runCase?case=$case_nr&agent=v-client'
mut ws := websocket.new_client(uri)!
ws.on_message(on_message)

2
vlib/net/websocket/tests/autobahn/autobahn_server.v
View File

@@ -10,7 +10,7 @@ fn main() {
}
fn handle_case(case_nr int) ! {
uri := 'ws://localhost:9002/runCase?case=$case_nr&agent=v-client'
uri := 'ws://localhost:9002/runCase?case=${case_nr}&agent=v-client'
mut ws := websocket.new_client(uri)!
ws.on_message(on_message)
ws.connect()!

6
vlib/net/websocket/tests/autobahn/local_run/autobahn_client.v
View File

@@ -5,8 +5,8 @@ import net.websocket
fn main() {
for i in 1 .. 304 {
println('\ncase: $i')
handle_case(i) or { println('error should be ok: $err') }
println('\ncase: ${i}')
handle_case(i) or { println('error should be ok: ${err}') }
}
// update the reports
uri := 'ws://localhost:9001/updateReports?agent=v-client'
@@ -16,7 +16,7 @@ fn main() {
}
fn handle_case(case_nr int) ! {
uri := 'ws://localhost:9001/runCase?case=$case_nr&agent=v-client'
uri := 'ws://localhost:9001/runCase?case=${case_nr}&agent=v-client'
mut ws := websocket.new_client(uri)!
ws.on_message(on_message)
ws.connect()!

6
vlib/net/websocket/tests/autobahn/local_run/autobahn_client_wss.v
View File

@@ -5,8 +5,8 @@ import net.websocket
fn main() {
for i in 1 .. 304 {
println('\ncase: $i')
handle_case(i) or { println('error should be ok: $err') }
println('\ncase: ${i}')
handle_case(i) or { println('error should be ok: ${err}') }
}
// update the reports
// uri := 'wss://localhost:9002/updateReports?agent=v-client'
@@ -17,7 +17,7 @@ fn main() {
}
fn handle_case(case_nr int) ! {
uri := 'wss://autobahn_server_wss:9002/runCase?case=$case_nr&agent=v-client'
uri := 'wss://autobahn_server_wss:9002/runCase?case=${case_nr}&agent=v-client'
// uri := 'wss://localhost:9002/runCase?case=$case_nr&agent=v-client'
mut ws := websocket.new_client(uri)!
ws.on_message(on_message)

38
vlib/net/websocket/websocket_client.v
View File

@@ -109,21 +109,21 @@ pub fn new_client(address string, opt ClientOpt) !&Client {
pub fn (mut ws Client) connect() ! {
ws.assert_not_connected()!
ws.set_state(.connecting)
ws.logger.info('connecting to host $ws.uri')
ws.logger.info('connecting to host ${ws.uri}')
ws.conn = ws.dial_socket()!
ws.handshake()!
ws.set_state(.open)
ws.logger.info('successfully connected to host $ws.uri')
ws.logger.info('successfully connected to host ${ws.uri}')
ws.send_open_event()
}
// listen listens and processes incoming messages
pub fn (mut ws Client) listen() ! {
mut log := 'Starting client listener, server($ws.is_server)...'
mut log := 'Starting client listener, server(${ws.is_server})...'
ws.logger.info(log)
unsafe { log.free() }
defer {
ws.logger.info('Quit client listener, server($ws.is_server)...')
ws.logger.info('Quit client listener, server(${ws.is_server})...')
if ws.state == .open {
ws.close(1000, 'closed by client') or {}
}
@@ -133,14 +133,14 @@ pub fn (mut ws Client) listen() ! {
if ws.state in [.closed, .closing] {
return
}
ws.debug_log('failed to read next message: $err')
ws.send_error_event('failed to read next message: $err')
ws.debug_log('failed to read next message: ${err}')
ws.send_error_event('failed to read next message: ${err}')
return err
}
if ws.state in [.closed, .closing] {
return
}
ws.debug_log('got message: $msg.opcode')
ws.debug_log('got message: ${msg.opcode}')
match msg.opcode {
.text_frame {
log = 'read: text'
@@ -157,8 +157,8 @@ pub fn (mut ws Client) listen() ! {
.ping {
ws.debug_log('read: ping, sending pong')
ws.send_control_frame(.pong, 'PONG', msg.payload) or {
ws.logger.error('error in message callback sending PONG: $err')
ws.send_error_event('error in message callback sending PONG: $err')
ws.logger.error('error in message callback sending PONG: ${err}')
ws.send_error_event('error in message callback sending PONG: ${err}')
if ws.panic_on_callback {
panic(err)
}
@@ -190,8 +190,8 @@ pub fn (mut ws Client) listen() ! {
}
code := u16(msg.payload[0]) << 8 | u16(msg.payload[1])
if code in invalid_close_codes {
ws.close(1002, 'invalid close code: $code')!
return error('invalid close code: $code')
ws.close(1002, 'invalid close code: ${code}')!
return error('invalid close code: ${code}')
}
reason := if msg.payload.len > 2 { msg.payload[2..] } else { []u8{} }
if reason.len > 0 {
@@ -199,7 +199,7 @@ pub fn (mut ws Client) listen() ! {
}
if ws.state !in [.closing, .closed] {
// sending close back according to spec
ws.debug_log('close with reason, code: $code, reason: $reason')
ws.debug_log('close with reason, code: ${code}, reason: ${reason}')
r := reason.bytestr()
ws.close(code, r)!
}
@@ -328,10 +328,10 @@ pub fn (mut ws Client) write_string(str string) !int {
// close closes the websocket connection
pub fn (mut ws Client) close(code int, message string) ! {
ws.debug_log('sending close, $code, $message')
ws.debug_log('sending close, ${code}, ${message}')
if ws.state in [.closed, .closing] || ws.conn.sock.handle <= 1 {
ws.debug_log('close: Websocket allready closed ($ws.state), $message, $code handle($ws.conn.sock.handle)')
err_msg := 'Socket allready closed: $code'
ws.debug_log('close: Websocket allready closed (${ws.state}), ${message}, ${code} handle(${ws.conn.sock.handle})')
err_msg := 'Socket allready closed: ${code}'
return error(err_msg)
}
defer {
@@ -360,7 +360,7 @@ pub fn (mut ws Client) close(code int, message string) ! {
// send_control_frame sends a control frame to the server
fn (mut ws Client) send_control_frame(code OPCode, frame_typ string, payload []u8) ! {
ws.debug_log('send control frame $code, frame_type: $frame_typ')
ws.debug_log('send control frame ${code}, frame_type: ${frame_typ}')
if ws.state !in [.open, .closing] && ws.conn.sock.handle > 1 {
return error('socket is not connected')
}
@@ -414,7 +414,7 @@ fn (mut ws Client) send_control_frame(code OPCode, frame_typ string, payload []u
}
}
ws.socket_write(control_frame) or {
return error('send_control_frame: error sending $frame_typ control frame.')
return error('send_control_frame: error sending ${frame_typ} control frame.')
}
}
@@ -474,9 +474,9 @@ fn (mut ws Client) reset_state() ! {
// debug_log handles debug logging output for client and server
fn (mut ws Client) debug_log(text string) {
if ws.is_server {
ws.logger.debug('server-> $text')
ws.logger.debug('server-> ${text}')
} else {
ws.logger.debug('client-> $text')
ws.logger.debug('client-> ${text}')
}
}

10
vlib/net/websocket/websocket_server.v
View File

@@ -61,15 +61,15 @@ pub fn (mut s Server) set_ping_interval(seconds int) {
// listen start listen and process to incoming connections from websocket clients
pub fn (mut s Server) listen() ! {
s.logger.info('websocket server: start listen on port $s.port')
s.ls = net.listen_tcp(s.family, ':$s.port')!
s.logger.info('websocket server: start listen on port ${s.port}')
s.ls = net.listen_tcp(s.family, ':${s.port}')!
s.set_state(.open)
spawn s.handle_ping()
for {
mut c := s.accept_new_client() or { continue }
spawn s.serve_client(mut c)
}
s.logger.info('websocket server: end listen on port $s.port')
s.logger.info('websocket server: end listen on port ${s.port}')
}
// Close closes server (not implemented yet)
@@ -111,9 +111,9 @@ fn (mut s Server) handle_ping() {
// serve_client accepts incoming connection and sets up the callbacks
fn (mut s Server) serve_client(mut c Client) ! {
c.logger.debug('server-> Start serve client ($c.id)')
c.logger.debug('server-> Start serve client (${c.id})')
defer {
c.logger.debug('server-> End serve client ($c.id)')
c.logger.debug('server-> End serve client (${c.id})')
}
mut handshake_response, mut server_client := s.handle_server_handshake(mut c)!
accept := s.send_connect_event(mut server_client)!

26
vlib/net/websocket/websocket_test.v
View File

@@ -26,11 +26,11 @@ fn test_ws_ipv6() {
return
}
port := 30000 + rand.intn(1024) or { 0 }
eprintln('> port ipv6: $port')
eprintln('> port ipv6: ${port}')
spawn start_server(.ip6, port)
time.sleep(1500 * time.millisecond)
ws_test(.ip6, 'ws://localhost:$port') or {
eprintln('> error while connecting .ip6, err: $err')
ws_test(.ip6, 'ws://localhost:${port}') or {
eprintln('> error while connecting .ip6, err: ${err}')
assert false
}
}
@@ -41,11 +41,11 @@ fn test_ws_ipv4() {
return
}
port := 30000 + rand.intn(1024) or { 0 }
eprintln('> port ipv4: $port')
eprintln('> port ipv4: ${port}')
spawn start_server(.ip, port)
time.sleep(1500 * time.millisecond)
ws_test(.ip, 'ws://localhost:$port') or {
eprintln('> error while connecting .ip, err: $err')
ws_test(.ip, 'ws://localhost:${port}') or {
eprintln('> error while connecting .ip, err: ${err}')
assert false
}
}
@@ -74,12 +74,12 @@ fn start_server(family net.AddrFamily, listen_port int) ! {
s.on_close(fn (mut ws websocket.Client, code int, reason string) ! {
// not used
})
s.listen() or { panic('websocket server could not listen, err: $err') }
s.listen() or { panic('websocket server could not listen, err: ${err}') }
}
// ws_test tests connect to the websocket server from websocket client
fn ws_test(family net.AddrFamily, uri string) ! {
eprintln('connecting to $uri ...')
eprintln('connecting to ${uri} ...')
mut test_results := WebsocketTestResults{}
mut ws := websocket.new_client(uri)!
@@ -88,13 +88,13 @@ fn ws_test(family net.AddrFamily, uri string) ! {
assert true
})
ws.on_error(fn (mut ws websocket.Client, err string) ! {
println('error: $err')
println('error: ${err}')
// this can be thrown by internet connection problems
assert false
})
ws.on_message_ref(fn (mut ws websocket.Client, msg &websocket.Message, mut res WebsocketTestResults) ! {
println('client got type: $msg.opcode payload:\n$msg.payload')
println('client got type: ${msg.opcode} payload:\n${msg.payload}')
if msg.opcode == .text_frame {
smessage := msg.payload.bytestr()
match smessage {
@@ -109,14 +109,14 @@ fn ws_test(family net.AddrFamily, uri string) ! {
}
}
} else {
println('Binary message: $msg')
println('Binary message: ${msg}')
}
}, test_results)
ws.connect() or { panic('fail to connect, err: $err') }
ws.connect() or { panic('fail to connect, err: ${err}') }
spawn ws.listen()
text := ['a'].repeat(2)
for msg in text {
ws.write(msg.bytes(), .text_frame) or { panic('fail to write to websocket, err: $err') }
ws.write(msg.bytes(), .text_frame) or { panic('fail to write to websocket, err: ${err}') }
// sleep to give time to recieve response before send a new one
time.sleep(100 * time.millisecond)
}