Zen

Source string Source string

329/10000 · 329
English Actions
If ``size`` is stated: on a UDP socket, excess bytes are discarded. On a TCP socket, excess bytes are not discarded and can be received by the next call.
Examples
Use of a TCP socket over the Internet
In this example a connection is made over the internet between a Tarantool instance and tarantool.org, then an HTTP "head" message is sent, and a response is received: "``HTTP/1.1 200 OK``" or something else if the site has moved. This is not a useful way to communicate with this particular site, but shows that the system works.
tarantool> socket = require('socket')
---
...
tarantool> sock = socket.tcp_connect('tarantool.org', 80)
---
...
tarantool> type(sock)
---
- table
...
tarantool> sock:error()
---
- null
...
tarantool> sock:send("HEAD / HTTP/1.0\r\nHost: tarantool.org\r\n\r\n")
---
- 40
...
tarantool> sock:read(17)
---
- HTTP/1.1 302 Move
...
tarantool> sock:close()
---
- true
...
Use of a socket with LuaSocket wrapper functions
This is a variation of the earlier example "Use of a TCP socket over the Internet". It uses :ref:`LuaSocket wrapper functions <socket-luasocket>`, with a too-short timeout so that a "Connection timed out" error is likely. The more common way to specify timeout is with an option of :ref:`tcp_connect() <socket-tcp_connect>`.
tarantool> socket = require('socket')
---
...
tarantool> sock = socket.connect('tarantool.org', 80)
---
...
tarantool> sock:settimeout(0.001)
---
- 1
...
tarantool> sock:send("HEAD / HTTP/1.0\r\nHost: tarantool.org\r\n\r\n")
---
- 40
...
tarantool> sock:receive(17)
---
- null
- Connection timed out
...
tarantool> sock:close()
---
- 1
...
Use of a UDP socket on localhost
Here is an example with datagrams. Set up two connections on 127.0.0.1 (localhost): ``sock_1`` and ``sock_2``. Using ``sock_2``, send a message to ``sock_1``. Using ``sock_1``, receive a message. Display the received message. Close both connections. |br| This is not a useful way for a computer to communicate with itself, but shows that the system works.
tarantool> socket = require('socket')
---
...
tarantool> sock_1 = socket('AF_INET', 'SOCK_DGRAM', 'udp')
---
...
tarantool> sock_1:bind('127.0.0.1')
---
- true
...
tarantool> sock_2 = socket('AF_INET', 'SOCK_DGRAM', 'udp')
---
...
tarantool> sock_2:sendto('127.0.0.1', sock_1:name().port,'X')
---
- 1
...
tarantool> message = sock_1:recvfrom(512)
---
...
tarantool> message
---
- X
...
tarantool> sock_1:close()
---
- true
...
tarantool> sock_2:close()
---
- true
...
Use tcp_server to accept file contents sent with socat
Here is an example of the tcp_server function, reading strings from the client and printing them. On the client side, the Linux socat utility will be used to ship a whole file for the tcp_server function to read.
Start two shells. The first shell will be a server instance. The second shell will be the client.
On the first shell, start Tarantool and say:
box.cfg{}
socket = require('socket')
socket.tcp_server('0.0.0.0', 3302,
{
handler = function(s)
while true do
local request
request = s:read("\n");
if request == "" or request == nil then
break
end
print(request)
end
end,
prepare = function()
print('Initialized')
end
}
)
The above code means:
Use ``tcp_server()`` to wait for a connection from any host on port 3302.
When it happens, enter a loop that reads on the socket and prints what it reads. The "delimiter" for the read function is "\\n" so each ``read()`` will read a string as far as the next line feed, including the line feed.
On the second shell, create a file that contains a few lines. The contents don't matter. Suppose the first line contains A, the second line contains B, the third line contains C. Call this file "tmp.txt".
On the second shell, use the socat utility to ship the tmp.txt file to the server instance's host and port:
$ socat TCP:localhost:3302 ./tmp.txt
Now watch what happens on the first shell. The strings "A", "B", "C" are printed.
Use tcp_server with handler and prepare
Here is an example of the tcp_server function using ``handler`` and ``prepare``.
box.cfg{}
socket = require('socket')
sock = socket.tcp_server(
'0.0.0.0',
3302,
{prepare =
function(sock)
print('listening on socket ' .. sock:fd())
sock:setsockopt('SOL_SOCKET','SO_REUSEADDR',true)
return 5
end,
handler =
function(sock, from)
print('accepted connection from: ')
print(' host: ' .. from.host)
print(' family: ' .. from.family)
print(' port: ' .. from.port)
end
}
)
Specify that there will be an initial call to ``prepare`` which displays something about the server, then calls ``setsockopt(...'SO_REUSEADDR'...)`` (this is the same option that Tarantool would set if there was no ``prepare``), and then returns 5 (this is a rather low backlog queue size).
Specify that there will be per-connection calls to ``handler`` which display something about the client.
Now watch what happens on the first shell. The display will include something like 'listening on socket 12'.
On the second shell, start Tarantool and say:
box.cfg{}
require('socket').tcp_connect('127.0.0.1', 3302)

Loading…

User avatar None

New source string

testing_project / Documentation: reference/reference_lua/socket — English

box.cfg{}
socket = require('socket')
socket.tcp_server('0.0.0.0', 3302,
{
handler = function(s)
while true do
local request
request = s:read("\n");
if request == "" or request == nil then
break
end
print(request)
end
end,
prepare = function()
print('Initialized')
end
}
)
a year ago
Browse all string changes

Things to check

Unpluralised

The string is used as plural, but not using plural forms

Reset

Glossary

English English
No related strings found in the glossary.

String information

Flags
read-only
String age
a year ago
Last updated
a year ago
Source string age
a year ago
Translation file
string 231