asynctnt.instance

Classes

TarantoolInstanceProtocol	Interface for protocol for subprocess calls.
TarantoolInstance
TarantoolSyncInstance
TarantoolAsyncInstance
TarantoolSyncDockerInstance

Module Contents

class asynctnt.instance.TarantoolInstanceProtocol(tnt, on_exit)

Bases: asyncio.SubprocessProtocol

Interface for protocol for subprocess calls.

_tnt

_on_exit

_transport = None

property logger

property pid

connection_made(transport)

Called when a connection is made.

The argument is the transport representing the pipe connection. To receive data, wait for data_received() calls. When the connection is closed, connection_lost() is called.

pipe_data_received(fd, data)

Called when the subprocess writes data into stdout/stderr pipe.

fd is int file descriptor. data is bytes object.

process_exited()

Called when subprocess has exited.

property returncode

async wait()

Wait until the process exit and return the process return code.

This method is a coroutine.

send_signal(signal)

terminate()

kill()

class asynctnt.instance.TarantoolInstance(*, host='127.0.0.1', port=3301, console_host=None, console_port=3302, replication_source=None, title=None, logger=None, log_level=5, slab_alloc_arena=0.1, wal_mode='none', root=None, specify_work_dir=True, cleanup=True, initlua_template=None, applua='-- app.lua --', extra_box_cfg='', timeout=5.0, command_to_run='tarantool', command_args=None)

_host = '127.0.0.1'

_port = 3301

_console_host = '127.0.0.1'

_console_port = 3302

_replication_source = None

_title

_logger

_log_level = 5

_slab_alloc_arena = 0.1

_wal_mode = 'none'

_root

_specify_work_dir = True

_cleanup = True

_initlua_template = Multiline-String

Show Value

"""
            local function check_version(expected, version)
                -- from tarantool/queue compat.lua
                local fun = require 'fun'
                local iter, op  = fun.iter, fun.operator
                local function split(self, sep)
                    local sep, fields = sep or ":", {}
                    local pattern = string.format("([^%s]+)", sep)
                    self:gsub(pattern, function(c) table.insert(fields, c) end)
                    return fields
                end

                local function reducer(res, l, r)
                    if res ~= nil then
                        return res
                    end
                    if tonumber(l) == tonumber(r) then
                        return nil
                    end
                    return tonumber(l) > tonumber(r)
                end

                local function split_version(version_string)
                    local vtable  = split(version_string, '.')
                    local vtable2 = split(vtable[3],  '-')
                    vtable[3], vtable[4] = vtable2[1], vtable2[2]
                    return vtable
                end

                local function check_version_internal(expected, version)
                    version = version or _TARANTOOL
                    if type(version) == 'string' then
                        version = split_version(version)
                    end
                    local res = iter(version):zip(expected)
                                             :reduce(reducer, nil)
                    if res or res == nil then res = true end
                    return res
                end

                return check_version_internal(expected, version)
            end
            local cfg = {
              listen = "${host}:${port}",
              wal_mode = "${wal_mode}",
              custom_proc_title = "${custom_proc_title}",
              slab_alloc_arena = ${slab_alloc_arena},
              work_dir = ${work_dir},
              log_level = ${log_level},
              ${extra_box_cfg}
            }
            if check_version({1, 7}, _TARANTOOL) then
                cfg.replication = ${replication_source}
            else
                local repl = ${replication_source}
                if type(repl) == 'table' then
                    repl = table.concat(repl, ',')
                end
                cfg.replication_source = repl
            end
            require('console').listen("${console_host}:${console_port}")
            box.cfg(cfg)
            box.schema.user.grant("guest", "read,write,execute", "universe",
                                  nil, {if_not_exists = true})
            ${applua}
        """

_applua = '-- app.lua --'

_extra_box_cfg = ''

_command_to_run = 'tarantool'

_command_args = None

_timeout = 5.0

_is_running = False

property replication_source

_random_string(length, *, source=string.ascii_uppercase + string.ascii_lowercase + string.digits)

_generate_title()

_generate_root_folder_name()

static get_random_port()

_create_initlua_template()

_render_initlua()

_save_initlua(initlua)

property logger

property fingerprint

prepare(recreate)

property host

property port

property console_port

property is_running

abstract property pid

abstract command(cmd, print_greeting=True)

abstract start(*, wait=True, recreate=True)

abstract stop()

abstract terminate()

abstract kill()

cleanup()

class asynctnt.instance.TarantoolSyncInstance(**kwargs)

Bases: TarantoolInstance

WAIT_TIMEOUT = 5

_process = None

_logger_thread = None

__enter__()

__exit__(exc_type, exc_val, exc_tb)

property pid

start(*, wait=True, recreate=True)

_log_reader()

stop()

terminate()

kill()

_wait(timeout, wait=True)

cleanup()

static _parse_version(version: str) → tuple | None

version() → tuple | None

property bin_version: tuple | None

command(cmd, print_greeting=True)

class asynctnt.instance.TarantoolAsyncInstance(**kwargs)

Bases: TarantoolInstance

_is_stopping = False

_transport = None

_protocol = None

_last_return_code = None

_stop_event

property pid

prepare(recreate)

_on_process_exit(return_code)

async wait_stopped()

async version()

async command(cmd, print_greeting=True)

async start(*, wait=True, recreate=True)

async stop()

terminate()

kill()

cleanup()

class asynctnt.instance.TarantoolSyncDockerInstance(*, docker_image=None, docker_tag=None, host='0.0.0.0', port=3301, console_host=None, console_port=3302, replication_source=None, title=None, logger=None, log_level=5, slab_alloc_arena=0.1, wal_mode='none', initlua_template=None, applua='-- app.lua --', timeout=10.0)

Bases: TarantoolSyncInstance

_docker_image = 'tarantool/tarantool'

_docker_tag = '1'

_command_to_run

_command_args

property bin_version: tuple | None