duel-mysql 0.1.7 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +41 -1
- data/README.md +10 -8
- data/lib/duel/mysql/version.rb +1 -1
- data/lib/duel/mysql.rb +432 -72
- data/sig/duel/mysql.rbs +138 -29
- metadata +43 -55
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 3c60008fbba47694875466924f67976f827b0ef49afb6b96c92ca2896382dc62
|
|
4
|
+
data.tar.gz: 54bf9e196f728fd2865ce153591ee8adbf95aa4d0f7a159adcb74a0c8aeada11
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: a30b65dae62d540c5c594dc41f1f730001351568a69c8f7496926060a6b97548b35fe12207722474b9e6237eeb3b1890ad28f83a5869a4875656fb7fcf1761b5
|
|
7
|
+
data.tar.gz: 8f7d1b46f6c71967bac9aa9dbaba01857da209b252022505e4f243cf123b298db435c3fbba32eeaa76243c7b3472b35f04d1f019dbc7bd1e8886807795cbc0de
|
data/CHANGELOG.md
CHANGED
|
@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|
|
7
7
|
|
|
8
8
|
## [Unreleased]
|
|
9
9
|
|
|
10
|
+
## [0.2.0] - 2026-11-16
|
|
11
|
+
|
|
12
|
+
### Added
|
|
13
|
+
|
|
14
|
+
- `tcp: true` starts each worker's server on a port of 127.0.0.1's
|
|
15
|
+
alone, its URL `mysql2://root@127.0.0.1:PORT/duel`, with no
|
|
16
|
+
`DUEL_MYSQL_SOCKET`. It's the default on Windows, whose MySQL has no
|
|
17
|
+
Unix socket.
|
|
18
|
+
|
|
19
|
+
### Changed
|
|
20
|
+
|
|
21
|
+
- The plugin reads the server's statistics with a client of its own,
|
|
22
|
+
in MySQL's protocol, so it no longer needs the trilogy gem (or a
|
|
23
|
+
build of it for Windows). `Duel::MySQL.execute` and `.reset`
|
|
24
|
+
return a `Duel::MySQL::Result`, and a statement that fails raises
|
|
25
|
+
`Duel::MySQL::Error`. Reading a server's statistics allocates a few
|
|
26
|
+
more objects than it did with Trilogy, which parsed MySQL's replies in
|
|
27
|
+
C (58 a reading, against 53.5, in the plugin's own benchmark), and
|
|
28
|
+
takes the same time. It gives up on a server that hasn't answered in
|
|
29
|
+
10 seconds, raising `IOError`, where it would wait forever.
|
|
30
|
+
|
|
31
|
+
### Fixed
|
|
32
|
+
|
|
33
|
+
- A `server:` path with a backslash in it (Windows's,
|
|
34
|
+
`C:\mysql\bin\mysqld`) is run as it is: the plugin looked for a
|
|
35
|
+
program by that name on the `PATH`.
|
|
36
|
+
- On Windows, `mysqld.exe` on the `PATH` (or a `server:` path without
|
|
37
|
+
its `.exe`) is found: the plugin looked for a file named `mysqld`.
|
|
38
|
+
|
|
39
|
+
## [0.1.8] - 2026-11-12
|
|
40
|
+
|
|
41
|
+
### Added
|
|
42
|
+
|
|
43
|
+
- Says each worker's server takes at most 450 MB
|
|
44
|
+
(`Duel::MySQL.worker_memory`), so Duel 0.1.8 or later fits no more
|
|
45
|
+
workers than that leaves room for, even where a server takes less as
|
|
46
|
+
it starts.
|
|
47
|
+
|
|
10
48
|
## [0.1.7] - 2026-11-10
|
|
11
49
|
|
|
12
50
|
No changes of its own: released in step with the other Duel gems.
|
|
@@ -101,7 +139,9 @@ or later (not MariaDB).
|
|
|
101
139
|
CI.
|
|
102
140
|
- RBS signatures in sig/, checked with Steep.
|
|
103
141
|
|
|
104
|
-
[Unreleased]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.
|
|
142
|
+
[Unreleased]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.2.0...HEAD
|
|
143
|
+
[0.2.0]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.1.8...duel-mysql-v0.2.0
|
|
144
|
+
[0.1.8]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.1.7...duel-mysql-v0.1.8
|
|
105
145
|
[0.1.7]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.1.6...duel-mysql-v0.1.7
|
|
106
146
|
[0.1.6]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.1.5...duel-mysql-v0.1.6
|
|
107
147
|
[0.1.5]: https://github.com/sferik/duel-ruby/compare/duel-mysql-v0.1.4...duel-mysql-v0.1.5
|
data/README.md
CHANGED
|
@@ -48,9 +48,8 @@ end
|
|
|
48
48
|
|
|
49
49
|
> [!NOTE]
|
|
50
50
|
> It needs MySQL 8.0.30 or later (not MariaDB: its `performance_schema`
|
|
51
|
-
> differs)
|
|
52
|
-
>
|
|
53
|
-
> run). Your code can use any client: trilogy is only the plugin's own.
|
|
51
|
+
> differs). The plugin reads the server's statistics with a small client
|
|
52
|
+
> of its own, so it needs no client gem, and your code can use any.
|
|
54
53
|
|
|
55
54
|
## Usage
|
|
56
55
|
|
|
@@ -62,16 +61,18 @@ Duel.configure { |c| c.use :mysql }
|
|
|
62
61
|
`c.use` requires the plugin, so `.duel.rb` doesn't need to.
|
|
63
62
|
|
|
64
63
|
Each worker's server listens only on a Unix socket in the worker's own
|
|
65
|
-
directory (
|
|
64
|
+
directory (or with `tcp: true`, on a port of 127.0.0.1's alone, as it
|
|
65
|
+
does by default on Windows, whose MySQL has no Unix socket). No
|
|
66
|
+
`my.cnf` is read, and it runs with no binary log, little memory,
|
|
66
67
|
nothing written to disk that needn't be, and InnoDB's statistics left as
|
|
67
68
|
they are (recalculated on their own, they'd change a query's plan while
|
|
68
69
|
it's measured: `ANALYZE TABLE` in a setup if you need them). Its URL is
|
|
69
70
|
in `DUEL_MYSQL_URL`, and in `DATABASE_URL` too, so a client that reads
|
|
70
71
|
that finds it and nothing reaches another database. The socket's path
|
|
71
|
-
is in `DUEL_MYSQL_SOCKET
|
|
72
|
+
is in `DUEL_MYSQL_SOCKET` (with `tcp`, there's none). Benchmarks can call `Duel::MySQL.url`,
|
|
72
73
|
`Duel::MySQL.socket`, `Duel::MySQL.execute` and `Duel::MySQL.reset`
|
|
73
|
-
(each of these two opens a connection of its own
|
|
74
|
-
|
|
74
|
+
(each of these two opens a connection of its own to the worker's
|
|
75
|
+
server, and closes it).
|
|
75
76
|
|
|
76
77
|
> [!IMPORTANT]
|
|
77
78
|
> `execute` and `reset` are for setting up: call them in a `setup` hook,
|
|
@@ -98,7 +99,8 @@ c.use :mysql,
|
|
|
98
99
|
args: ["--sort-buffer-size=4M"], # more of its options
|
|
99
100
|
setup: File.read("db/structure.sql"), # SQL each worker's database runs first
|
|
100
101
|
env: %w[DATABASE_URL PRIMARY_URL], # variables given its URL besides DUEL_MYSQL_URL
|
|
101
|
-
scheme: "trilogy"
|
|
102
|
+
scheme: "trilogy", # the URL's (Rails takes it for the adapter, mysql2 by default)
|
|
103
|
+
tcp: true # on a port of 127.0.0.1's, its URL mysql2://root@127.0.0.1:PORT/duel (default: on Windows only)
|
|
102
104
|
```
|
|
103
105
|
|
|
104
106
|
> [!WARNING]
|
data/lib/duel/mysql/version.rb
CHANGED
data/lib/duel/mysql.rb
CHANGED
|
@@ -3,6 +3,8 @@
|
|
|
3
3
|
require "duel"
|
|
4
4
|
require "digest"
|
|
5
5
|
require "fileutils"
|
|
6
|
+
require "rbconfig"
|
|
7
|
+
require "socket"
|
|
6
8
|
require_relative "mysql/version"
|
|
7
9
|
|
|
8
10
|
module Duel
|
|
@@ -25,9 +27,12 @@ module Duel
|
|
|
25
27
|
# .reset in setup (or untimed blocks): while a benchmark is measured,
|
|
26
28
|
# they fail.
|
|
27
29
|
#
|
|
28
|
-
# The server listens only on a Unix socket in the worker's directory
|
|
29
|
-
#
|
|
30
|
-
#
|
|
30
|
+
# The server listens only on a Unix socket in the worker's directory
|
|
31
|
+
# (or with +tcp+, on a port of 127.0.0.1's alone: by default on Windows,
|
|
32
|
+
# whose MySQL has none); its URL is in DUEL_MYSQL_URL, and in
|
|
33
|
+
# DATABASE_URL too (unless +env+ names others), and the socket's path
|
|
34
|
+
# in DUEL_MYSQL_SOCKET (with +tcp+, none). The plugin's connections are
|
|
35
|
+
# a client of its own (see Connection): no gem's.
|
|
31
36
|
module MySQL
|
|
32
37
|
Duel.plugin(:mysql, self)
|
|
33
38
|
|
|
@@ -37,13 +42,14 @@ module Duel
|
|
|
37
42
|
USER = "root"
|
|
38
43
|
|
|
39
44
|
# The server's options (after --no-defaults: no my.cnf of the
|
|
40
|
-
# machine's):
|
|
45
|
+
# machine's): errors to its output (its log: on Windows, they'd go to a
|
|
46
|
+
# file of their own), nothing to disk that needn't be, little
|
|
41
47
|
# memory, no Linux AIO contexts (there are only so many, for every
|
|
42
48
|
# server on the machine), and nothing running on its own
|
|
43
49
|
# (recalculating a table's statistics would change its plans while
|
|
44
50
|
# they're measured).
|
|
45
51
|
OPTIONS = %w[
|
|
46
|
-
--
|
|
52
|
+
--console --mysqlx=OFF --skip-log-bin
|
|
47
53
|
--innodb-buffer-pool-size=32M --innodb-redo-log-capacity=8M --innodb-doublewrite=OFF --innodb-use-native-aio=OFF
|
|
48
54
|
--innodb-flush-log-at-trx-commit=0 --innodb-stats-auto-recalc=OFF --event-scheduler=OFF --performance-schema=ON
|
|
49
55
|
].freeze
|
|
@@ -52,6 +58,11 @@ module Duel
|
|
|
52
58
|
# what's in it is thrown away).
|
|
53
59
|
RUNNING = %w[--innodb-fast-shutdown=2].freeze
|
|
54
60
|
|
|
61
|
+
# The most memory a worker's server takes (see Duel.plugin), even with
|
|
62
|
+
# OPTIONS: some 450 MB, measured on a GitHub runner, more than it
|
|
63
|
+
# takes as it starts, before it's used.
|
|
64
|
+
def self.worker_memory = 450 << 20
|
|
65
|
+
|
|
55
66
|
# Configures Duel for the plugin (c.use :mysql): the server and its
|
|
56
67
|
# metrics. +server+ is the program, +args+ more of its options,
|
|
57
68
|
# +setup+ SQL each worker's database runs when it's started (a
|
|
@@ -62,40 +73,46 @@ module Duel
|
|
|
62
73
|
# to it, a worker's (see Config#in_worker, and in tests,
|
|
63
74
|
# Duel::Testing.in_worker).
|
|
64
75
|
def self.configure(config, server: ENV.fetch("DUEL_MYSQL_SERVER", "mysqld"), args: [], setup: nil, env: %w[DATABASE_URL],
|
|
65
|
-
scheme: "mysql2")
|
|
76
|
+
scheme: "mysql2", tcp: !Duel.unix_sockets?)
|
|
66
77
|
config.prepare(:worker) do |w|
|
|
67
78
|
program = DataDir.find_server(server) || w.failed("no #{server} on the PATH (give it as server:, or DUEL_MYSQL_SERVER)")
|
|
68
79
|
data = w.path("data")
|
|
69
80
|
DataDir.new(w, program).create(data)
|
|
81
|
+
# (A Unix socket even with +tcp+, which MySQL can't do without:
|
|
82
|
+
# its own default's in a directory of the system's.)
|
|
70
83
|
socket = w.path("mysqld.sock")
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
84
|
+
if tcp
|
|
85
|
+
port = w.port
|
|
86
|
+
listen = ["--port=#{port}", "--bind-address=127.0.0.1", "--socket=#{socket}"]
|
|
87
|
+
address = "127.0.0.1:#{port}"
|
|
88
|
+
url = "#{scheme}://#{USER}@127.0.0.1:#{port}/#{DATABASE}"
|
|
89
|
+
vars = {URL => url}
|
|
90
|
+
else
|
|
91
|
+
# (No network at all.)
|
|
92
|
+
address = socket
|
|
93
|
+
listen = ["--skip-networking", "--socket=#{socket}"]
|
|
94
|
+
url = "#{scheme}://#{USER}@localhost/#{DATABASE}?socket=#{address}"
|
|
95
|
+
vars = {URL => url, SOCKET => address}
|
|
96
|
+
end
|
|
97
|
+
w.spawn(program, *(DataDir.options(data) + listen), "--pid-file=#{w.path("mysqld.pid")}", "--tmpdir=#{w.dir}", *(RUNNING + args))
|
|
98
|
+
# (Stopped with SHUTDOWN, before it's killed: on Windows, mysqld is
|
|
99
|
+
# a monitor, the server its child, which killing it would leave
|
|
100
|
+
# running.)
|
|
101
|
+
w.at_stop { shutdown(address) }
|
|
102
|
+
w.wait_until { Connection.ping(address) }
|
|
103
|
+
run(address, setup) if setup
|
|
104
|
+
vars.merge(env.to_h { |name| [name, url] })
|
|
105
|
+
end
|
|
106
|
+
connection = config.in_worker { |w| Connection.new(address).tap { |mysql| w.at_stop { mysql.close } } }
|
|
79
107
|
statements = Statements.new(connection)
|
|
80
108
|
config.metric(METRICS) { statements.read }.costly.details { |stretches, sample| statements.details(stretches, sample.n) }
|
|
81
109
|
connection
|
|
82
110
|
end
|
|
83
111
|
|
|
84
|
-
#
|
|
85
|
-
#
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
# say), and keep it. (In the runner, which loads no version, the
|
|
89
|
-
# bundle's.)
|
|
90
|
-
# mutant:disable -- the tests' process has Trilogy loaded from the start,
|
|
91
|
-
# so a require changes nothing there: test_loads_trilogy_only_when_used
|
|
92
|
-
# checks it, in a process of its own
|
|
93
|
-
def self.require_trilogy = require("trilogy")
|
|
94
|
-
|
|
95
|
-
# Runs SQL on a connection of its own to the server on +socket+;
|
|
96
|
-
# returns the last statement's result.
|
|
97
|
-
def self.run(socket, sql)
|
|
98
|
-
connection = Connection.new(socket)
|
|
112
|
+
# Runs SQL on a connection of its own to the server at +address+ (its
|
|
113
|
+
# socket's path, or HOST:PORT); returns the last statement's result.
|
|
114
|
+
def self.run(address, sql)
|
|
115
|
+
connection = Connection.new(address)
|
|
99
116
|
begin
|
|
100
117
|
connection.execute(sql)
|
|
101
118
|
ensure
|
|
@@ -103,6 +120,13 @@ module Duel
|
|
|
103
120
|
end
|
|
104
121
|
end
|
|
105
122
|
|
|
123
|
+
# Asks the server at +address+ to shut down, if it's there to ask.
|
|
124
|
+
def self.shutdown(address)
|
|
125
|
+
run(address, "SHUTDOWN")
|
|
126
|
+
rescue Error, SystemCallError, IOError
|
|
127
|
+
nil # (gone already, or gone as it answered)
|
|
128
|
+
end
|
|
129
|
+
|
|
106
130
|
# Server time isn't the worker's CPU time: another process's, on the
|
|
107
131
|
# clock, so what else the machine does shows in it. It's judged on
|
|
108
132
|
# each benchmark, but left out across the board, where the margin is
|
|
@@ -162,7 +186,7 @@ module Duel
|
|
|
162
186
|
# (Connection#quote'd: the plugin's own readings'). A statement's run
|
|
163
187
|
# (LAST_SEEN) is when it ended, but it's counted just after.
|
|
164
188
|
DIGESTS = <<~SQL
|
|
165
|
-
SELECT
|
|
189
|
+
SELECT COUNT_STAR, SUM_ROWS_SENT + SUM_ROWS_AFFECTED, SUM_ROWS_EXAMINED, SUM_TIMER_WAIT, DIGEST
|
|
166
190
|
FROM performance_schema.events_statements_summary_by_digest
|
|
167
191
|
WHERE DIGEST IS NOT NULL AND UNIX_TIMESTAMP(LAST_SEEN) >= %d AND DIGEST NOT IN (%s)
|
|
168
192
|
SQL
|
|
@@ -189,13 +213,10 @@ module Duel
|
|
|
189
213
|
end
|
|
190
214
|
end
|
|
191
215
|
|
|
192
|
-
# The same by measure (time in µs).
|
|
193
|
-
def self.stats(connection) = Statements.by_measure(totals(connection))
|
|
194
|
-
|
|
195
216
|
# What the server has done so far, by statement, read over
|
|
196
217
|
# +connection+: those run since +since+ (seconds since the epoch), but
|
|
197
|
-
# the +own+ digests, each one's [
|
|
198
|
-
#
|
|
218
|
+
# the +own+ digests, each one's [queries, rows, rows examined, time
|
|
219
|
+
# (ps), digest].
|
|
199
220
|
def self.digests(connection, since, own)
|
|
200
221
|
connection.query(format(DIGESTS, since, own.map { |digest| connection.quote(digest) }.join(", "))).rows
|
|
201
222
|
end
|
|
@@ -212,26 +233,35 @@ module Duel
|
|
|
212
233
|
# For benchmarks: the worker's server.
|
|
213
234
|
def self.url = ENV.fetch(URL)
|
|
214
235
|
|
|
215
|
-
# Its socket's path (for a client that takes it, not a URL).
|
|
236
|
+
# Its socket's path (for a client that takes it, not a URL). With
|
|
237
|
+
# +tcp+, there's none (see .url).
|
|
216
238
|
def self.socket = ENV.fetch(SOCKET)
|
|
217
239
|
|
|
240
|
+
# Where it is, for the plugin's own connections: its socket's path, or
|
|
241
|
+
# (with +tcp+) its URL's HOST:PORT, in +env+ (a worker's).
|
|
242
|
+
def self.address(env = ENV)
|
|
243
|
+
# (Or the URL's: one the plugin made, so it has a HOST:PORT, which
|
|
244
|
+
# Steep can't tell.)
|
|
245
|
+
env.fetch(SOCKET) { env.fetch(URL)[%r{@([^/]+)/}, 1] } # steep:ignore BlockBodyTypeMismatch
|
|
246
|
+
end
|
|
247
|
+
|
|
218
248
|
# Runs SQL (statements, ;-separated) on it, over a connection of its
|
|
219
249
|
# own; returns the last one's result. For setting up: it fails while
|
|
220
250
|
# a benchmark is measured (Duel.measuring?), as what it runs would be
|
|
221
251
|
# counted.
|
|
222
252
|
def self.execute(sql)
|
|
223
253
|
Duel.unmeasured!("Duel::MySQL.execute")
|
|
224
|
-
run(
|
|
254
|
+
run(address, sql)
|
|
225
255
|
end
|
|
226
256
|
|
|
227
257
|
# Empties every table in its database, restarting their
|
|
228
258
|
# AUTO_INCREMENTs. For setting up, as execute is.
|
|
229
259
|
def self.reset
|
|
230
260
|
Duel.unmeasured!("Duel::MySQL.reset")
|
|
231
|
-
tables = run(
|
|
261
|
+
tables = run(address, "SELECT table_name FROM information_schema.tables " \
|
|
232
262
|
"WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'").map(&:first)
|
|
233
263
|
# (Only this connection's: it's closed after.)
|
|
234
|
-
run(
|
|
264
|
+
run(address, "SET FOREIGN_KEY_CHECKS = 0#{tables.map { |table| "; TRUNCATE TABLE `#{table}`" }.join}")
|
|
235
265
|
end
|
|
236
266
|
|
|
237
267
|
# Running totals of what the worker's server did, all told (#read),
|
|
@@ -246,10 +276,6 @@ module Duel
|
|
|
246
276
|
SHOWN = 3
|
|
247
277
|
TEXT = 80
|
|
248
278
|
|
|
249
|
-
# A statement not read yet, as a row of MySQL.digests: it did
|
|
250
|
-
# nothing.
|
|
251
|
-
UNREAD = [nil, 0, 0, 0, 0].freeze
|
|
252
|
-
|
|
253
279
|
# A statement that did nothing yet.
|
|
254
280
|
NOTHING = [0, 0, 0, 0].freeze
|
|
255
281
|
|
|
@@ -259,9 +285,10 @@ module Duel
|
|
|
259
285
|
# No statement changed.
|
|
260
286
|
UNCHANGED = [] #: Array[String]
|
|
261
287
|
|
|
262
|
-
# A reading's context: every statement's row as of it
|
|
263
|
-
#
|
|
264
|
-
# reading's, and the digests of
|
|
288
|
+
# A reading's context: every statement's row as of it (its numbers,
|
|
289
|
+
# then its digest), by digest (a Hash it shares with the last
|
|
290
|
+
# reading, if none changed), the last reading's, and the digests of
|
|
291
|
+
# those that changed since.
|
|
265
292
|
Reading = Data.define(:rows, :previous, :changed)
|
|
266
293
|
|
|
267
294
|
# How long before a reading (in seconds) the next one reads the
|
|
@@ -335,7 +362,7 @@ module Duel
|
|
|
335
362
|
rows = previous
|
|
336
363
|
changed = UNCHANGED
|
|
337
364
|
MySQL.digests(connection, since, own).each do |row|
|
|
338
|
-
digest = row.
|
|
365
|
+
digest = row.last
|
|
339
366
|
next if row == previous[digest]
|
|
340
367
|
|
|
341
368
|
# (The last reading's Hash is its own: copied, at the first change.)
|
|
@@ -367,9 +394,9 @@ module Duel
|
|
|
367
394
|
digests = after.previous.equal?(before) ? after.changed : after.rows.keys
|
|
368
395
|
digests.each do |digest|
|
|
369
396
|
now = after.rows.fetch(digest)
|
|
370
|
-
was = before.fetch(digest,
|
|
397
|
+
was = before.fetch(digest, NOTHING)
|
|
371
398
|
so_far = grew.fetch(digest, NOTHING)
|
|
372
|
-
grew[digest] = Array.new(NAMES.size) { |i| so_far.fetch(i) + now.fetch(i
|
|
399
|
+
grew[digest] = Array.new(NAMES.size) { |i| so_far.fetch(i) + now.fetch(i) - was.fetch(i) }
|
|
373
400
|
end
|
|
374
401
|
end
|
|
375
402
|
grew.select { |_, more| more.any?(&:positive?) }
|
|
@@ -386,46 +413,379 @@ module Duel
|
|
|
386
413
|
def shorten(text) = (text.length > TEXT) ? "#{text[0, TEXT - 1]}…" : text
|
|
387
414
|
end
|
|
388
415
|
|
|
389
|
-
#
|
|
416
|
+
# What a connection to a worker's server raises where it fails: a
|
|
417
|
+
# statement's error (its code and message), or a reply it can't read.
|
|
418
|
+
class Error < Duel::Error
|
|
419
|
+
# The server's error code, or nil (not the server's error).
|
|
420
|
+
attr_reader :code
|
|
421
|
+
|
|
422
|
+
def initialize(message, code: nil)
|
|
423
|
+
super(message)
|
|
424
|
+
@code = code
|
|
425
|
+
end
|
|
426
|
+
end
|
|
427
|
+
|
|
428
|
+
# A query's result: its columns' names, and its rows, each value a
|
|
429
|
+
# String, but an integer column's an Integer, a floating-point one's a
|
|
430
|
+
# Float, and NULL nil. (One that returns none, an INSERT's, say, has
|
|
431
|
+
# neither.)
|
|
432
|
+
class Result
|
|
433
|
+
include Enumerable
|
|
434
|
+
|
|
435
|
+
attr_reader :fields, :rows
|
|
436
|
+
|
|
437
|
+
# (Given in order, not by keyword: a keyword's Hash would be made for
|
|
438
|
+
# every query.)
|
|
439
|
+
def initialize(fields, rows)
|
|
440
|
+
@fields = fields
|
|
441
|
+
@rows = rows
|
|
442
|
+
end
|
|
443
|
+
|
|
444
|
+
def each(&) = rows.each(&)
|
|
445
|
+
end
|
|
446
|
+
|
|
447
|
+
# The least a connection needs to read a server's statistics: not the
|
|
448
|
+
# code's own, whose statements are what's measured. As root (with no
|
|
449
|
+
# password: the data directory's initialized with none), to its
|
|
450
|
+
# database, over its Unix socket (a path), or over TCP (HOST:PORT: on
|
|
451
|
+
# Windows), in MySQL's text protocol: statements, several to a query
|
|
452
|
+
# if need be, and their results, the last one's returned.
|
|
390
453
|
class Connection
|
|
391
|
-
#
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
454
|
+
# What the client says it can do: protocol 4.1's packets, a
|
|
455
|
+
# database to connect to, transactions' statuses, 4.1's (and 8.0's)
|
|
456
|
+
# authentication, several statements to a query, and their results.
|
|
457
|
+
LONG_PASSWORD = 0x1
|
|
458
|
+
CONNECT_WITH_DB = 0x8
|
|
459
|
+
PROTOCOL_41 = 0x200
|
|
460
|
+
TRANSACTIONS = 0x2000
|
|
461
|
+
SECURE_CONNECTION = 0x8000
|
|
462
|
+
MULTI_STATEMENTS = 0x10000
|
|
463
|
+
MULTI_RESULTS = 0x20000
|
|
464
|
+
PLUGIN_AUTH = 0x80000
|
|
465
|
+
CAPABILITIES = LONG_PASSWORD | CONNECT_WITH_DB | PROTOCOL_41 | TRANSACTIONS | SECURE_CONNECTION | MULTI_STATEMENTS | MULTI_RESULTS |
|
|
466
|
+
PLUGIN_AUTH
|
|
467
|
+
# The largest packet it takes, and its character set (utf8mb4).
|
|
468
|
+
MAX_PACKET = (1 << 24) - 1
|
|
469
|
+
UTF8MB4 = 45
|
|
470
|
+
|
|
471
|
+
# A packet's first byte: an OK, an error, an end of rows (EOF, of
|
|
472
|
+
# fewer than 9 bytes), or more of authentication's (caching_sha2_
|
|
473
|
+
# password's: FAST_AUTH, the password matched what it had cached).
|
|
474
|
+
OK = 0x00
|
|
475
|
+
ERR = 0xFF
|
|
476
|
+
EOF = 0xFE
|
|
477
|
+
AUTH_SWITCH = 0xFE
|
|
478
|
+
AUTH_MORE = 0x01
|
|
479
|
+
FAST_AUTH = 0x03
|
|
480
|
+
COM_QUERY = 0x03
|
|
481
|
+
# A NULL value in a row, and lenenc integers' prefixes.
|
|
482
|
+
NULL = 0xFB
|
|
483
|
+
# An OK's or EOF's status: more results to come.
|
|
484
|
+
MORE_RESULTS = 0x08
|
|
485
|
+
|
|
486
|
+
# The column types read as Integers (TINY, SHORT, LONG, LONGLONG,
|
|
487
|
+
# INT24, YEAR) and as Floats (FLOAT, DOUBLE).
|
|
488
|
+
INTEGERS = [1, 2, 3, 8, 9, 13].freeze
|
|
489
|
+
FLOATS = [4, 5].freeze
|
|
490
|
+
|
|
491
|
+
# What the client says it is when the server's gone.
|
|
492
|
+
CLOSED = "MySQL closed the connection"
|
|
493
|
+
|
|
494
|
+
# How long, in seconds, it waits for the server's next packet before
|
|
495
|
+
# it gives up: a server that's stuck (or sent a packet's length
|
|
496
|
+
# wrong) would have it wait forever.
|
|
497
|
+
TIMEOUT = 10
|
|
498
|
+
|
|
499
|
+
# Whether a server answers at +address+.
|
|
500
|
+
def self.ping(address)
|
|
501
|
+
new(address).close
|
|
502
|
+
rescue Error, SystemCallError, IOError
|
|
395
503
|
false
|
|
396
504
|
end
|
|
397
505
|
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
506
|
+
# The host and port of a HOST:PORT address, or nil (a Unix socket's
|
|
507
|
+
# path).
|
|
508
|
+
def self.address(address)
|
|
509
|
+
match = %r{\A([^:/]+):(\d+)\z}.match(address) or return
|
|
510
|
+
[match[1], Integer(match[2])]
|
|
402
511
|
end
|
|
403
512
|
|
|
404
|
-
|
|
513
|
+
# A socket to +address+, without TCP's delay before a small write
|
|
514
|
+
# (a statement), whose reply would wait for it.
|
|
515
|
+
def self.socket(address)
|
|
516
|
+
host_and_port = address(address)
|
|
517
|
+
return UNIXSocket.new(address) unless host_and_port
|
|
405
518
|
|
|
406
|
-
|
|
407
|
-
|
|
519
|
+
host, port = host_and_port
|
|
520
|
+
# (RBS's setsockopt takes an Integer for the value, but Ruby's
|
|
521
|
+
# takes true too.)
|
|
522
|
+
TCPSocket.new(host, port).tap { |socket| socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true) } # steep:ignore ArgumentTypeMismatch
|
|
523
|
+
end
|
|
408
524
|
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
525
|
+
def initialize(address, database: DATABASE, timeout: TIMEOUT)
|
|
526
|
+
@socket = Connection.socket(address)
|
|
527
|
+
@timeout = timeout
|
|
528
|
+
# (Buffers of its own, binary (one byte a byte), read into
|
|
529
|
+
# and written from again and again: a packet's header, and its
|
|
530
|
+
# payload, which is read before the next one is, and what's written
|
|
531
|
+
# before a payload. Where the packet's read up to (@at), the last
|
|
532
|
+
# one's sequence number, and whether more results follow the last
|
|
533
|
+
# one read, are set as each is read.)
|
|
534
|
+
@header = "".b
|
|
535
|
+
@packet = "".b
|
|
536
|
+
@out = "".b
|
|
537
|
+
begin
|
|
538
|
+
authenticate(database)
|
|
539
|
+
rescue Exception # rubocop:disable Lint/RescueException
|
|
540
|
+
close
|
|
541
|
+
raise
|
|
542
|
+
end
|
|
543
|
+
end
|
|
544
|
+
|
|
545
|
+
# Runs +sql+ (statements, ;-separated); returns the last one's
|
|
546
|
+
# result. A statement that fails raises its Error.
|
|
547
|
+
def query(sql)
|
|
548
|
+
write(sql, 0, COM_QUERY)
|
|
549
|
+
loop do
|
|
550
|
+
result = next_result
|
|
551
|
+
return result unless @more
|
|
552
|
+
end
|
|
414
553
|
end
|
|
415
554
|
|
|
555
|
+
# Runs statements; returns the last one's result.
|
|
556
|
+
def execute(sql) = query(sql)
|
|
557
|
+
|
|
558
|
+
# +text+ as a string literal.
|
|
559
|
+
def quote(text) = "'#{text.gsub(/[\0\n\r\\'"\x1a]/, ESCAPES)}'"
|
|
560
|
+
|
|
561
|
+
ESCAPES = {"\0" => "\\0", "\n" => "\\n", "\r" => "\\r", "\\" => "\\\\", "'" => "\\'", "\"" => "\\\"", "\x1a" => "\\Z"}.freeze
|
|
562
|
+
|
|
416
563
|
# Closes it without telling the server (no QUIT, which the server
|
|
417
564
|
# could read after a benchmark's started, and count); true.
|
|
418
|
-
def close
|
|
565
|
+
def close
|
|
566
|
+
@socket.close
|
|
567
|
+
true
|
|
568
|
+
end
|
|
569
|
+
|
|
570
|
+
private
|
|
571
|
+
|
|
572
|
+
# The server's greeting (a handshake, protocol 10), and the client's
|
|
573
|
+
# reply: root, with no password (an empty response, whichever plugin
|
|
574
|
+
# the server authenticates with), to +database+. Fails unless it's
|
|
575
|
+
# let in.
|
|
576
|
+
def authenticate(database)
|
|
577
|
+
greeting = read
|
|
578
|
+
error!(greeting) if greeting.getbyte(0) == ERR
|
|
579
|
+
# (Its last string: the scramble before it has no NUL in it.)
|
|
580
|
+
plugin = greeting.split("\0").last #: String
|
|
581
|
+
# (23 bytes reserved, and the response's length, 0, before the
|
|
582
|
+
# database.)
|
|
583
|
+
# (The greeting's numbered 0, and the reply 1.)
|
|
584
|
+
write([CAPABILITIES, MAX_PACKET, UTF8MB4, USER, database, plugin].pack("VVCx23Z*xZ*Z*"), 1)
|
|
585
|
+
loop do
|
|
586
|
+
reply = read
|
|
587
|
+
case reply.getbyte(0)
|
|
588
|
+
when OK then return
|
|
589
|
+
when ERR then error!(reply)
|
|
590
|
+
# (Another plugin: an empty response again.)
|
|
591
|
+
when AUTH_SWITCH then write("", @sequence + 1)
|
|
592
|
+
# (caching_sha2_password's: the empty password matched.)
|
|
593
|
+
when AUTH_MORE then raise Error, "MySQL wants a password (root's has none)" unless reply.getbyte(1) == FAST_AUTH
|
|
594
|
+
else raise Error, "MySQL: an authentication reply the connection doesn't read: #{reply.getbyte(0)}"
|
|
595
|
+
end
|
|
596
|
+
end
|
|
597
|
+
end
|
|
598
|
+
|
|
599
|
+
# A statement's result (and in @more, whether more follow): an OK's
|
|
600
|
+
# (no rows), or a result set's (its columns, then its rows, each
|
|
601
|
+
# ended by an EOF). An error raises it.
|
|
602
|
+
def next_result
|
|
603
|
+
packet = read
|
|
604
|
+
case packet.getbyte(0)
|
|
605
|
+
when OK
|
|
606
|
+
# (Its status after its affected rows and insert id.)
|
|
607
|
+
@at = 1
|
|
608
|
+
lenenc(packet)
|
|
609
|
+
lenenc(packet)
|
|
610
|
+
@more = more?(packet, @at)
|
|
611
|
+
Result.new(NONE, NONE)
|
|
612
|
+
when ERR then error!(packet)
|
|
613
|
+
else
|
|
614
|
+
@at = 0
|
|
615
|
+
count = lenenc(packet)
|
|
616
|
+
names = [] #: Array[String]
|
|
617
|
+
types = [] #: Array[Integer]
|
|
618
|
+
count.times { column(read, names, types) }
|
|
619
|
+
read # (the columns' EOF)
|
|
620
|
+
rows = [] #: Array[Array[untyped]]
|
|
621
|
+
rows << row(packet, types) until eof?(packet = read)
|
|
622
|
+
# (Its status after its warnings.)
|
|
623
|
+
@more = more?(packet, 3)
|
|
624
|
+
Result.new(names, rows)
|
|
625
|
+
end
|
|
626
|
+
end
|
|
627
|
+
|
|
628
|
+
# An OK's result: no fields, and no rows.
|
|
629
|
+
NONE = Array.new(0).freeze
|
|
630
|
+
|
|
631
|
+
# Whether an OK's or an EOF's status, at +at+, says more results
|
|
632
|
+
# follow. (Its first byte, of two, little-endian, has the flag.)
|
|
633
|
+
def more?(packet, at)
|
|
634
|
+
status = packet.getbyte(at) #: Integer
|
|
635
|
+
(status & MORE_RESULTS).positive?
|
|
636
|
+
end
|
|
637
|
+
|
|
638
|
+
# An EOF: one of fewer than 9 bytes that starts with EOF (a row can
|
|
639
|
+
# too, with a value's 8-byte length).
|
|
640
|
+
def eof?(packet) = packet.getbyte(0) == EOF && packet.bytesize < 9
|
|
641
|
+
|
|
642
|
+
# A column's name and its type, added to +names+ and +types+: after
|
|
643
|
+
# four lenenc strings (its catalog, schema, table, original table),
|
|
644
|
+
# its name, its original name, and its fixed fields' length, its
|
|
645
|
+
# character set (2 bytes) and length (4), then its type.
|
|
646
|
+
def column(packet, names, types)
|
|
647
|
+
@at = 0
|
|
648
|
+
4.times { skip(packet) }
|
|
649
|
+
names << string(packet, lenenc(packet)).force_encoding(Encoding::UTF_8)
|
|
650
|
+
skip(packet)
|
|
651
|
+
lenenc(packet)
|
|
652
|
+
type = packet.getbyte(@at + 6) #: Integer
|
|
653
|
+
types << type
|
|
654
|
+
end
|
|
655
|
+
|
|
656
|
+
# A row's values, by its columns' +types+.
|
|
657
|
+
def row(packet, types)
|
|
658
|
+
@at = 0
|
|
659
|
+
types.map do |type|
|
|
660
|
+
if packet.getbyte(@at) == NULL
|
|
661
|
+
@at += 1
|
|
662
|
+
next
|
|
663
|
+
end
|
|
664
|
+
|
|
665
|
+
length = lenenc(packet)
|
|
666
|
+
if INTEGERS.include?(type)
|
|
667
|
+
integer(packet, length)
|
|
668
|
+
elsif FLOATS.include?(type)
|
|
669
|
+
Float(string(packet, length))
|
|
670
|
+
else
|
|
671
|
+
string(packet, length).force_encoding(Encoding::UTF_8)
|
|
672
|
+
end
|
|
673
|
+
end
|
|
674
|
+
end
|
|
675
|
+
|
|
676
|
+
# The integer written (in decimal, with a sign if it's negative) in
|
|
677
|
+
# the +length+ bytes at the packet's @at, read on past them. (Read
|
|
678
|
+
# byte by byte, so that no String is made of them.)
|
|
679
|
+
def integer(packet, length)
|
|
680
|
+
stop = @at + length
|
|
681
|
+
negative = packet.getbyte(@at) == MINUS
|
|
682
|
+
@at += 1 if negative
|
|
683
|
+
value = 0
|
|
684
|
+
while @at < stop
|
|
685
|
+
digit = packet.getbyte(@at) #: Integer
|
|
686
|
+
value = (value * 10) + digit - ZERO
|
|
687
|
+
@at += 1
|
|
688
|
+
end
|
|
689
|
+
negative ? -value : value
|
|
690
|
+
end
|
|
691
|
+
|
|
692
|
+
# A minus sign's byte, and a 0's.
|
|
693
|
+
MINUS = 0x2D
|
|
694
|
+
ZERO = 0x30
|
|
695
|
+
|
|
696
|
+
# The +length+ bytes at the packet's @at, as a String of their own,
|
|
697
|
+
# read on past them.
|
|
698
|
+
def string(packet, length)
|
|
699
|
+
string = packet.byteslice(@at, length) #: String
|
|
700
|
+
@at += length
|
|
701
|
+
string
|
|
702
|
+
end
|
|
703
|
+
|
|
704
|
+
# A length-encoded string at the packet's @at, skipped. (Its length
|
|
705
|
+
# read first: it moves @at past itself.)
|
|
706
|
+
def skip(packet)
|
|
707
|
+
length = lenenc(packet)
|
|
708
|
+
@at += length
|
|
709
|
+
end
|
|
710
|
+
|
|
711
|
+
# The length-encoded integer at the packet's @at, read on past it.
|
|
712
|
+
def lenenc(packet)
|
|
713
|
+
at = @at
|
|
714
|
+
first = packet.getbyte(at) #: Integer
|
|
715
|
+
# (Looked up, not fetched with a block, which would make a Proc
|
|
716
|
+
# for each one read.)
|
|
717
|
+
size = LENGTHS[first]
|
|
718
|
+
unless size
|
|
719
|
+
@at = at + 1
|
|
720
|
+
return first
|
|
721
|
+
end
|
|
722
|
+
# (Its bytes, little-endian.)
|
|
723
|
+
value = 0
|
|
724
|
+
size.times do |i|
|
|
725
|
+
byte = packet.getbyte(at + 1 + i) #: Integer
|
|
726
|
+
value += byte << (8 * i)
|
|
727
|
+
end
|
|
728
|
+
@at = at + 1 + size
|
|
729
|
+
value
|
|
730
|
+
end
|
|
731
|
+
|
|
732
|
+
# A length-encoded integer's prefixes, and its bytes after them (one
|
|
733
|
+
# under 0xFB is the integer itself).
|
|
734
|
+
LENGTHS = {0xFC => 2, 0xFD => 3, 0xFE => 8}.freeze
|
|
735
|
+
|
|
736
|
+
# The next packet's payload (in a buffer that the one after it is
|
|
737
|
+
# read into), its sequence number in @sequence.
|
|
738
|
+
def read
|
|
739
|
+
# (Its length in 3 bytes, then its sequence number.)
|
|
740
|
+
header = read_exactly(4, @header).unpack1("V") #: Integer
|
|
741
|
+
@sequence = header >> 24
|
|
742
|
+
read_exactly(header & MAX_PACKET, @packet)
|
|
743
|
+
end
|
|
744
|
+
|
|
745
|
+
def read_exactly(size, buffer)
|
|
746
|
+
raise IOError, "MySQL didn't answer in #{@timeout} seconds" unless @socket.wait_readable(@timeout)
|
|
747
|
+
|
|
748
|
+
data = @socket.read(size, buffer)
|
|
749
|
+
raise IOError, CLOSED unless data && data.bytesize == size
|
|
750
|
+
|
|
751
|
+
data
|
|
752
|
+
end
|
|
753
|
+
|
|
754
|
+
# Writes a packet: +payload+, after +command+'s byte if there's one,
|
|
755
|
+
# numbered +sequence+. (Its header: its length in 3 bytes, then its
|
|
756
|
+
# sequence number.)
|
|
757
|
+
def write(payload, sequence, command = nil)
|
|
758
|
+
size = payload.bytesize + (command ? 1 : 0)
|
|
759
|
+
out = @out.clear
|
|
760
|
+
out << (size & 0xFF) << ((size >> 8) & 0xFF) << (size >> 16) << sequence
|
|
761
|
+
out << command if command
|
|
762
|
+
@socket.write(out, payload)
|
|
763
|
+
end
|
|
764
|
+
|
|
765
|
+
# Raises an error packet's error: its code (2 bytes), its SQL state
|
|
766
|
+
# (# and 5 characters), and its message.
|
|
767
|
+
def error!(packet)
|
|
768
|
+
code = packet.unpack1("v", offset: 1) #: Integer
|
|
769
|
+
start = (packet.getbyte(3) == 35) ? 9 : 3 # (after the SQL state, where there's one)
|
|
770
|
+
message = packet.byteslice(start..) #: String
|
|
771
|
+
message.force_encoding(Encoding::UTF_8)
|
|
772
|
+
raise Error.new("MySQL: #{message} (#{code})", code: code)
|
|
773
|
+
end
|
|
419
774
|
end
|
|
420
775
|
|
|
421
776
|
# A worker's data directory: a copy of one initialized once, with the
|
|
422
777
|
# database created in it.
|
|
423
778
|
class DataDir
|
|
424
|
-
#
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
779
|
+
# A program's file ends with +EXE+: on Windows, .exe.
|
|
780
|
+
EXE = RbConfig::CONFIG["EXEEXT"]
|
|
781
|
+
|
|
782
|
+
# The server program: +server+ if it's a path (a / or, on Windows, a
|
|
783
|
+
# \ in it), or the one by that name on +path+; nil if there's none.
|
|
784
|
+
# Either may end with +exe+ too (on Windows, .exe: mysqld.exe, for
|
|
785
|
+
# mysqld).
|
|
786
|
+
def self.find_server(server, path = ENV.fetch("PATH", ""), exe: EXE)
|
|
787
|
+
files = server.match?(%r{[/\\]}) ? [server] : path.split(File::PATH_SEPARATOR).map { |dir| File.join(dir, server) }
|
|
788
|
+
files.flat_map { |file| [file, "#{file}#{exe}"] }.find { |file| File.executable?(file) }
|
|
429
789
|
end
|
|
430
790
|
|
|
431
791
|
# The options the server's run with, initializing +data+ or not.
|
data/sig/duel/mysql.rbs
CHANGED
|
@@ -38,23 +38,27 @@ module Duel
|
|
|
38
38
|
# rows examined, time (ps).
|
|
39
39
|
type numbers = Array[Integer]
|
|
40
40
|
|
|
41
|
-
# A statement's row, as MySQL.digests reads it: [
|
|
41
|
+
# A statement's row, as MySQL.digests reads it: [*numbers, digest].
|
|
42
42
|
type row = Array[untyped]
|
|
43
43
|
|
|
44
44
|
# Configures Duel for the plugin (c.use :mysql): the server (+server+
|
|
45
45
|
# the program, +args+ more of its options, +setup+ SQL each worker's
|
|
46
46
|
# database runs when it's started, +env+ the variables besides
|
|
47
|
-
# DUEL_MYSQL_URL given its URL, +scheme+ the URL's
|
|
48
|
-
#
|
|
47
|
+
# DUEL_MYSQL_URL given its URL, +scheme+ the URL's, +tcp+ on a port
|
|
48
|
+
# of 127.0.0.1's: by default on Windows) and its metrics. Returns the
|
|
49
|
+
# plugin's own connection to it, a worker's.
|
|
49
50
|
def self.configure: (Config config, ?server: String, ?args: Array[String], ?setup: String?, ?env: Array[String],
|
|
50
|
-
?scheme: String) -> InWorker[Connection]
|
|
51
|
+
?scheme: String, ?tcp: bool) -> InWorker[Connection]
|
|
51
52
|
|
|
52
|
-
#
|
|
53
|
+
# The most memory a worker's server takes.
|
|
54
|
+
def self.worker_memory: () -> Integer
|
|
55
|
+
|
|
56
|
+
# Runs SQL on a connection of its own to the server at +address+;
|
|
53
57
|
# returns the last statement's result.
|
|
54
|
-
|
|
55
|
-
def self.require_trilogy: () -> bool
|
|
58
|
+
def self.run: (String address, String sql) -> Result
|
|
56
59
|
|
|
57
|
-
|
|
60
|
+
# Asks the server at +address+ to shut down, if it's there to ask.
|
|
61
|
+
def self.shutdown: (String address) -> void
|
|
58
62
|
|
|
59
63
|
# What the worker's server has done so far, but for the plugin's own
|
|
60
64
|
# connection, which reads it.
|
|
@@ -64,12 +68,9 @@ module Duel
|
|
|
64
68
|
# running a statement.
|
|
65
69
|
def self.settle: (Connection connection) -> void
|
|
66
70
|
|
|
67
|
-
# The same by measure.
|
|
68
|
-
def self.stats: (Connection connection) -> Snapshot::totals[Metric::value]
|
|
69
|
-
|
|
70
71
|
# What the server has done so far, by statement, read over
|
|
71
72
|
# +connection+: those run since +since+, but the +own+ digests, each
|
|
72
|
-
# one's [
|
|
73
|
+
# one's [*numbers, digest].
|
|
73
74
|
def self.digests: (Connection connection, Integer since, Array[String] own) -> Array[row]
|
|
74
75
|
|
|
75
76
|
# The digest of each of +statements+, read over +connection+.
|
|
@@ -85,13 +86,23 @@ module Duel
|
|
|
85
86
|
# Its socket's path.
|
|
86
87
|
def self.socket: () -> String
|
|
87
88
|
|
|
89
|
+
# The environment (ENV, or a Hash in its place).
|
|
90
|
+
interface _Env
|
|
91
|
+
def fetch: (String name) -> String
|
|
92
|
+
| (String name) { (String name) -> String } -> String
|
|
93
|
+
end
|
|
94
|
+
|
|
95
|
+
# Where it is, for the plugin's own connections: its socket's path, or
|
|
96
|
+
# its URL's HOST:PORT.
|
|
97
|
+
def self.address: (?_Env env) -> String
|
|
98
|
+
|
|
88
99
|
# Runs SQL on it, over a connection of its own; returns the last
|
|
89
100
|
# statement's result. For setting up: it fails while a benchmark is
|
|
90
101
|
# measured.
|
|
91
|
-
def self.execute: (String sql) ->
|
|
102
|
+
def self.execute: (String sql) -> Result
|
|
92
103
|
|
|
93
104
|
# Empties every table in its database. For setting up, as execute is.
|
|
94
|
-
def self.reset: () ->
|
|
105
|
+
def self.reset: () -> Result
|
|
95
106
|
|
|
96
107
|
# Running totals of what the worker's server did, all told, and by
|
|
97
108
|
# statement, to explain a regression.
|
|
@@ -104,9 +115,6 @@ module Duel
|
|
|
104
115
|
SHOWN: Integer
|
|
105
116
|
TEXT: Integer
|
|
106
117
|
|
|
107
|
-
# A statement not read yet, as a row of MySQL.digests.
|
|
108
|
-
UNREAD: row
|
|
109
|
-
|
|
110
118
|
# A statement that did nothing yet.
|
|
111
119
|
NOTHING: numbers
|
|
112
120
|
|
|
@@ -166,35 +174,136 @@ module Duel
|
|
|
166
174
|
def shorten: (String text) -> String
|
|
167
175
|
end
|
|
168
176
|
|
|
169
|
-
#
|
|
170
|
-
class
|
|
171
|
-
@
|
|
177
|
+
# What a connection to a worker's server raises where it fails.
|
|
178
|
+
class Error < Duel::Error
|
|
179
|
+
@code: Integer?
|
|
172
180
|
|
|
173
|
-
#
|
|
174
|
-
|
|
181
|
+
# The server's error code, or nil.
|
|
182
|
+
attr_reader code: Integer?
|
|
175
183
|
|
|
176
|
-
def initialize: (String
|
|
184
|
+
def initialize: (String message, ?code: Integer?) -> void
|
|
185
|
+
end
|
|
177
186
|
|
|
178
|
-
|
|
187
|
+
# A query's result: its columns' names, and its rows.
|
|
188
|
+
class Result
|
|
189
|
+
include Enumerable[Array[untyped]]
|
|
179
190
|
|
|
180
|
-
|
|
181
|
-
|
|
191
|
+
attr_reader fields: Array[String]
|
|
192
|
+
attr_reader rows: Array[Array[untyped]]
|
|
193
|
+
|
|
194
|
+
def initialize: (Array[String] fields, Array[Array[untyped]] rows) -> void
|
|
195
|
+
|
|
196
|
+
def each: () { (Array[untyped] row) -> void } -> Array[Array[untyped]]
|
|
197
|
+
end
|
|
198
|
+
|
|
199
|
+
# The least a connection needs to read a server's statistics, in
|
|
200
|
+
# MySQL's text protocol: as root, to its database.
|
|
201
|
+
class Connection
|
|
202
|
+
LONG_PASSWORD: Integer
|
|
203
|
+
CONNECT_WITH_DB: Integer
|
|
204
|
+
PROTOCOL_41: Integer
|
|
205
|
+
TRANSACTIONS: Integer
|
|
206
|
+
SECURE_CONNECTION: Integer
|
|
207
|
+
MULTI_STATEMENTS: Integer
|
|
208
|
+
MULTI_RESULTS: Integer
|
|
209
|
+
PLUGIN_AUTH: Integer
|
|
210
|
+
CAPABILITIES: Integer
|
|
211
|
+
MAX_PACKET: Integer
|
|
212
|
+
UTF8MB4: Integer
|
|
213
|
+
OK: Integer
|
|
214
|
+
ERR: Integer
|
|
215
|
+
EOF: Integer
|
|
216
|
+
AUTH_SWITCH: Integer
|
|
217
|
+
AUTH_MORE: Integer
|
|
218
|
+
FAST_AUTH: Integer
|
|
219
|
+
COM_QUERY: Integer
|
|
220
|
+
NULL: Integer
|
|
221
|
+
MORE_RESULTS: Integer
|
|
222
|
+
INTEGERS: Array[Integer]
|
|
223
|
+
FLOATS: Array[Integer]
|
|
224
|
+
CLOSED: String
|
|
225
|
+
TIMEOUT: Integer
|
|
226
|
+
ESCAPES: Hash[String, String]
|
|
227
|
+
LENGTHS: Hash[Integer, Integer]
|
|
228
|
+
NONE: Array[untyped]
|
|
229
|
+
MINUS: Integer
|
|
230
|
+
ZERO: Integer
|
|
231
|
+
|
|
232
|
+
@socket: UNIXSocket | TCPSocket
|
|
233
|
+
@timeout: Integer | Float
|
|
234
|
+
@header: String
|
|
235
|
+
@packet: String
|
|
236
|
+
@out: String
|
|
237
|
+
@at: Integer
|
|
238
|
+
@sequence: Integer
|
|
239
|
+
@more: bool
|
|
240
|
+
|
|
241
|
+
# Whether a server answers at +address+.
|
|
242
|
+
def self.ping: (String address) -> bool
|
|
243
|
+
|
|
244
|
+
# The host and port of a HOST:PORT address, or nil.
|
|
245
|
+
def self.address: (String address) -> [String, Integer]?
|
|
246
|
+
|
|
247
|
+
# A socket to +address+.
|
|
248
|
+
def self.socket: (String address) -> (UNIXSocket | TCPSocket)
|
|
249
|
+
|
|
250
|
+
def initialize: (String address, ?database: String, ?timeout: Integer | Float) -> void
|
|
251
|
+
|
|
252
|
+
def query: (String sql) -> Result
|
|
182
253
|
|
|
183
254
|
# Runs statements; returns the last one's result.
|
|
184
|
-
def execute: (String sql) ->
|
|
255
|
+
def execute: (String sql) -> Result
|
|
256
|
+
|
|
257
|
+
# +text+ as a string literal.
|
|
258
|
+
def quote: (String text) -> String
|
|
185
259
|
|
|
186
260
|
# Closes it without telling the server (no QUIT); true.
|
|
187
261
|
def close: () -> bool
|
|
262
|
+
|
|
263
|
+
private
|
|
264
|
+
|
|
265
|
+
def authenticate: (String database) -> void
|
|
266
|
+
|
|
267
|
+
# A statement's result (and in @more, whether more follow).
|
|
268
|
+
def next_result: () -> Result
|
|
269
|
+
|
|
270
|
+
def more?: (String packet, Integer at) -> bool
|
|
271
|
+
|
|
272
|
+
def eof?: (String packet) -> bool
|
|
273
|
+
|
|
274
|
+
# A column's name and its type, the +i+th of +names+ and +types+.
|
|
275
|
+
def column: (String packet, Array[String] names, Array[Integer] types) -> Array[Integer]
|
|
276
|
+
|
|
277
|
+
def row: (String packet, Array[Integer] types) -> Array[untyped]
|
|
278
|
+
|
|
279
|
+
def integer: (String packet, Integer length) -> Integer
|
|
280
|
+
|
|
281
|
+
def string: (String packet, Integer length) -> String
|
|
282
|
+
|
|
283
|
+
def skip: (String packet) -> Integer
|
|
284
|
+
|
|
285
|
+
def lenenc: (String packet) -> Integer
|
|
286
|
+
|
|
287
|
+
# The next packet's payload.
|
|
288
|
+
def read: () -> String
|
|
289
|
+
|
|
290
|
+
def read_exactly: (Integer size, String buffer) -> String
|
|
291
|
+
|
|
292
|
+
def write: (String payload, Integer sequence, ?Integer? command) -> Integer
|
|
293
|
+
|
|
294
|
+
def error!: (String packet) -> bot
|
|
188
295
|
end
|
|
189
296
|
|
|
190
297
|
# A worker's data directory: a copy of one initialized once.
|
|
191
298
|
class DataDir
|
|
299
|
+
EXE: String
|
|
300
|
+
|
|
192
301
|
@resource: Resource
|
|
193
302
|
@server: String
|
|
194
303
|
|
|
195
304
|
# The server program: +server+ if it's a path, or the one by that
|
|
196
|
-
# name on +path
|
|
197
|
-
def self.find_server: (String server, ?String path) -> String?
|
|
305
|
+
# name on +path+ (either may end with +exe+ too); nil if there's none.
|
|
306
|
+
def self.find_server: (String server, ?String path, ?exe: String) -> String?
|
|
198
307
|
|
|
199
308
|
# The options the server's run with, initializing a data directory
|
|
200
309
|
# or not.
|
metadata
CHANGED
|
@@ -1,80 +1,68 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: duel-mysql
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.
|
|
4
|
+
version: 0.2.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
|
-
- Erik Berlin
|
|
7
|
+
- Erik Berlin
|
|
8
8
|
bindir: bin
|
|
9
9
|
cert_chain: []
|
|
10
10
|
date: 1980-01-02 00:00:00.000000000 Z
|
|
11
11
|
dependencies:
|
|
12
|
-
- !ruby/object:Gem::Dependency
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
- !ruby/object:Gem::
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
requirements:
|
|
30
|
-
- - "~>"
|
|
31
|
-
- !ruby/object:Gem::Version
|
|
32
|
-
version: '2.9'
|
|
33
|
-
type: :runtime
|
|
34
|
-
prerelease: false
|
|
35
|
-
version_requirements: !ruby/object:Gem::Requirement
|
|
36
|
-
requirements:
|
|
37
|
-
- - "~>"
|
|
38
|
-
- !ruby/object:Gem::Version
|
|
39
|
-
version: '2.9'
|
|
40
|
-
description: 'A Duel plugin: each worker gets a MySQL server of its own, and every
|
|
41
|
-
benchmark is judged on the statements it sent, the rows they read and their time
|
|
42
|
-
too.'
|
|
12
|
+
- !ruby/object:Gem::Dependency
|
|
13
|
+
name: duel
|
|
14
|
+
requirement: !ruby/object:Gem::Requirement
|
|
15
|
+
requirements:
|
|
16
|
+
-
|
|
17
|
+
- ~>
|
|
18
|
+
- !ruby/object:Gem::Version
|
|
19
|
+
version: "0.2"
|
|
20
|
+
type: :runtime
|
|
21
|
+
prerelease: false
|
|
22
|
+
version_requirements: !ruby/object:Gem::Requirement
|
|
23
|
+
requirements:
|
|
24
|
+
-
|
|
25
|
+
- ~>
|
|
26
|
+
- !ruby/object:Gem::Version
|
|
27
|
+
version: "0.2"
|
|
28
|
+
description: "A Duel plugin: each worker gets a MySQL server of its own, and every benchmark is judged on the statements it sent, the rows they read and their time too."
|
|
43
29
|
email:
|
|
44
|
-
- sferik@gmail.com
|
|
30
|
+
- sferik@gmail.com
|
|
45
31
|
executables: []
|
|
46
32
|
extensions: []
|
|
47
33
|
extra_rdoc_files: []
|
|
48
34
|
files:
|
|
49
|
-
- CHANGELOG.md
|
|
50
|
-
- LICENSE
|
|
51
|
-
- README.md
|
|
52
|
-
- lib/duel/mysql.rb
|
|
53
|
-
- lib/duel/mysql/version.rb
|
|
54
|
-
- sig/duel/mysql.rbs
|
|
55
|
-
homepage: https://github.com/sferik/duel-ruby/tree/main/plugins/mysql
|
|
35
|
+
- CHANGELOG.md
|
|
36
|
+
- LICENSE
|
|
37
|
+
- README.md
|
|
38
|
+
- lib/duel/mysql.rb
|
|
39
|
+
- lib/duel/mysql/version.rb
|
|
40
|
+
- sig/duel/mysql.rbs
|
|
41
|
+
homepage: "https://github.com/sferik/duel-ruby/tree/main/plugins/mysql"
|
|
56
42
|
licenses:
|
|
57
|
-
- MIT
|
|
43
|
+
- MIT
|
|
58
44
|
metadata:
|
|
59
|
-
source_code_uri: https://github.com/sferik/duel-ruby/tree/main/plugins/mysql
|
|
60
|
-
changelog_uri: https://github.com/sferik/duel-ruby/blob/main/plugins/mysql/CHANGELOG.md
|
|
61
|
-
bug_tracker_uri: https://github.com/sferik/duel-ruby/issues
|
|
62
|
-
rubygems_mfa_required:
|
|
45
|
+
source_code_uri: "https://github.com/sferik/duel-ruby/tree/main/plugins/mysql"
|
|
46
|
+
changelog_uri: "https://github.com/sferik/duel-ruby/blob/main/plugins/mysql/CHANGELOG.md"
|
|
47
|
+
bug_tracker_uri: "https://github.com/sferik/duel-ruby/issues"
|
|
48
|
+
rubygems_mfa_required: "true"
|
|
63
49
|
rdoc_options: []
|
|
64
50
|
require_paths:
|
|
65
|
-
- lib
|
|
51
|
+
- lib
|
|
66
52
|
required_ruby_version: !ruby/object:Gem::Requirement
|
|
67
53
|
requirements:
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
54
|
+
-
|
|
55
|
+
- ">="
|
|
56
|
+
- !ruby/object:Gem::Version
|
|
57
|
+
version: "3.4"
|
|
71
58
|
required_rubygems_version: !ruby/object:Gem::Requirement
|
|
72
59
|
requirements:
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
60
|
+
-
|
|
61
|
+
- ">="
|
|
62
|
+
- !ruby/object:Gem::Version
|
|
63
|
+
version: "0"
|
|
76
64
|
requirements: []
|
|
77
|
-
rubygems_version: 4.0
|
|
65
|
+
rubygems_version: 4.1.0
|
|
78
66
|
specification_version: 4
|
|
79
|
-
summary: A MySQL server for each Duel worker, and what it did for each benchmark
|
|
67
|
+
summary: "A MySQL server for each Duel worker, and what it did for each benchmark"
|
|
80
68
|
test_files: []
|