From 89d8092b3423be0e48e2db8691201d08c41a9b77 Mon Sep 17 00:00:00 2001 From: joshua Date: Sun, 3 Aug 2025 10:27:57 -0400 Subject: [PATCH] Spell checking and stuff --- .../ROOT/pages/database-export-import.adoc | 101 ++++++++- .../modules/ROOT/pages/troubleshooting.adoc | 4 - .../pages/troubleshooting/connection.adoc | 31 +++ .../troubleshooting/debugging-queries.adoc | 39 ++++ .../ROOT/pages/troubleshooting/index.adoc | 39 ++++ .../pages/troubleshooting/installation.adoc | 26 +++ .../troubleshooting/optimising-queries.adoc | 119 +++++++++++ .../troubleshooting/stopping-queries.adoc | 35 ++++ .../modules/ROOT/pages/typedb-backups.adoc | 19 +- .../modules/ROOT/pages/typedb-upgrades.adoc | 18 +- .../modules/ROOT/partials/nav.adoc | 7 +- new_tools/modules/ROOT/pages/console.adoc | 191 ++++++++++++++++-- new_tools/modules/ROOT/pages/ide-plugins.adoc | 20 +- 13 files changed, 611 insertions(+), 38 deletions(-) delete mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting.adoc create mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting/connection.adoc create mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting/debugging-queries.adoc create mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting/index.adoc create mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting/installation.adoc create mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting/optimising-queries.adoc create mode 100644 new_maintenance_operation/modules/ROOT/pages/troubleshooting/stopping-queries.adoc diff --git a/new_maintenance_operation/modules/ROOT/pages/database-export-import.adoc b/new_maintenance_operation/modules/ROOT/pages/database-export-import.adoc index 5709dd83b..1252a19ff 100644 --- a/new_maintenance_operation/modules/ROOT/pages/database-export-import.adoc +++ b/new_maintenance_operation/modules/ROOT/pages/database-export-import.adoc @@ -1,4 +1,101 @@ = Database Export & Import -[placeholder] -Export and import TypeDB databases. \ No newline at end of file +Use TypeDB's built-in export functionality to export a database as a complete TypeQL schema file and a binary containing the instances in the database. + +The built-in import functionality can be used to create a database from an exported data binary and a complete schema. + +Exported binary data is designed to be identical across any version of TypeDB. This means you can reload your database in versions of TypeDB that are no longer compatible on the data layer (such as moving from TypeDB 2.x to 3.x). + +[IMPORTANT] +==== +This feature is introduced in TypeDB 3.4.0. If you want to export or import a database from earlier versions of TypeDB 3.x, simply update your server and client and follow this manual. + +You can import your databases exported from TypeDB 2.x following xref:{page-version}@manual::migration/2_to_3/process.adoc[this guide]. +==== + +== Understanding export and import + +TypeDB database can be represented as two files: + +[#_files] +1. A text file with its TypeQL schema description: a complete `define` query for the whole schema. +2. A binary file with its data. + +An exported database can be imported into another version of TypeDB using these two files. +This is the best tool you can use to migrate a database between two incompatible versions of TypeDB (e.g., a migration xref:{page-version}@manual::migration/2_to_3/process.adoc[from TypeDB 2.x to TypeDB 3.x]). + +Both operations are performed through the network, but the server and the client can be used on the same host. + +Examples below use xref:{page-version}@new_home::install/console-cli.adoc[TypeDB Console] as the most accessible client for these operations. +Please check the xref:{page-version}@new_reference::typedb-grpc-drivers/index.html[gRPC Drivers API] to explore available programmatic commands. + +[#_export] +== Export + +Database export allows a client to download xref:#_files[database schema and data files] from a TypeDB server for future import to the same or higher TypeDB version. + +The files are created on the client side. +The exported binary file might be up to two times larger than the original database. +If the client connects to a remote host, the server's disk remains unchanged, thus introducing zero risks to the stability of the server. +Please ensure the client's disk has enough free capacity to store a file of this size. + +While the database data is being exported, parallel transactions are allowed, but none of them will affect the exported data thanks to TypeDB's xref:{page-version}@new_core_concepts::typedb/transactions.adoc[transactional nature]. +However, the database will not be available for operations such as deletion. + +[NOTE] +==== +The files can be incomplete and corrupted if the export operation is interrupted by the user. Please restart and obtain a complete data file in one attempt. +==== + +=== Using TypeDB Console + +1. Make sure that your TypeDB Server is running. + +2. Follow xref:{page-version}@new_tools::console.adoc[Console page] to set up a connection. + +3. Execute `database export database-name schema.typeql data.typedb`, where + +- `database-name` is the name of the exported database; +- `schema.typeql` is the exported schema definition file path; +- `data.typedb` is the exported data file path. + +4. The result (either `Successfully exported database` or an error) will be printed to the Console. + +== Import + +Database import allows a client to upload previously exported xref:#_files[database schema and data files] to a TypeDB server. + +For your safety, the imported database should not exist on the target server. +It is possible to assign any new name to the imported database. + +[NOTE] +==== +The database will be incomplete (and thus not recommended for usage) if the import operation is interrupted. +It is expected to be automatically removed from the disk, but a small number of unexpected technical issues can prevent this from happening. +A server restart will resolve any related issues. +==== + +=== Using TypeDB Console + +1. Make sure that your TypeDB Server is running. + +2. Follow xref:{page-version}@new_tools::console.adoc[Console page] to set up a connection. + +3. Execute `database import database-name schema.typeql data.typedb`, where + +- `database-name` is the new name of the imported database; +- `schema.typeql` is the imported schema definition file path; +- `data.typedb` is the imported data file path. + +4. The result (either `Successfully imported database` or an error) will be printed to the Console. + +== Troubleshooting + +Follow this checklist if any errors occur: + +* Ensure that you use xref:{page-version}@new_tools::console.adoc#version-compatibility[compatible] TypeDB Server and TypeDB Console. +* Ensure that the correct file paths were specified for the operations. +* If you import a TypeDB 2.x database, some errors may be expected. +Check out xref:{page-version}@manual::migration/2_to_3/process.adoc[this page] for a detailed guide. + +If any errors persist, please join one of our communities and ask for assistance. diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting.adoc deleted file mode 100644 index e679392eb..000000000 --- a/new_maintenance_operation/modules/ROOT/pages/troubleshooting.adoc +++ /dev/null @@ -1,4 +0,0 @@ -= Troubleshooting - -[placeholder] -Troubleshoot TypeDB issues. \ No newline at end of file diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting/connection.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/connection.adoc new file mode 100644 index 000000000..4bfba18a2 --- /dev/null +++ b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/connection.adoc @@ -0,0 +1,31 @@ += Connecting + +This page contains the most common issues that may be encountered during development with respect to connecting to a TypeDB server. + +== Connection refused + +[source] +---- +$ ./typedb console --address localhost:1729 --username admin --password password +tcp connect error: Connection refused (os error 61) +---- + +Receiving this error message from Console or Driver indicates that they are unable to establish a connection to the server. The most common reasons could be: + +- The server is not running +- The server is configured at a different host or port to what the client is attempting to connect to +- The connection is blocked by a firewall + +== TLS errors + +[source] +---- +$ ./typedb console --address https://localhost:1729 --username admin --password password --tls-disabled +Connecting to HTTPS without TLS enabled +---- + +Receiving this error message from Console or Driver indicates that TLS is not properly configured from the Console or Driver side. + +When using TLS encryption, ensure it is configured on both the server and the driver. **Drivers connecting to TLS-secured servers must use the `https://` prefix.** + +Similarly, when disabling TLS encryption, ensure both server and driver are configured to not use TLS, and the driver connects without an `https://` prefix. diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting/debugging-queries.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/debugging-queries.adoc new file mode 100644 index 000000000..6a4125123 --- /dev/null +++ b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/debugging-queries.adoc @@ -0,0 +1,39 @@ += Debugging queries + +This page summarizes general steps and ideas for debugging TypeDB queries. + +== Locating errors + +When your query returns an error, the TypeDB server will report a stack trace of error messages; you will find the most relevant message on the top of that trace. + +* In the case of a syntax error, the error message will indicate the line and character position where the error occurred. + +* In other cases, the error message should give an indication of which logical conflicts caused the error in the database. A natural debugging approach is to isolate the part of the query that you believe caused that conflict, and then make the necessary changes before returning to your larger query. + +* Unexpected pipeline result. When a query results in an unexpected output or data write, the simplest way to debug the query is to take advantage of TypeQL's compositional nature. Simply remove query clauses to inspect intermediate query operations when debugging a pipeline. + +* Unexpected clause result. To debug an individual clause, again you can take advantage of TypeQL's compositional nature. Split the clause into smaller clauses and execute them one by one to see their results, pinpointing the part that misbehaves. + +== Dissecting stages + +In complex pipelines, it is often useful to truncate your query to specific stages. This allows you to inspect "`intermediate results`". You can output results for specific variables of those stages using the `select` operator. It is also often useful to simply output the number of results of (a part of) your pipeline via the `reduce` operator: + +[,typeql] +---- +... # incoming pipeline +reduce $c = count; # outputs answer count of incoming pipeline +---- + +== Limiting queries + +If query executes indefinitely and does not return results, a sanity check that it can potentially produce at least one result in a reasonable time is always a good idea: + +[,typeql] +---- +... # incoming pipeline +limit 1; # stops the execution after consuming one answer +---- + +== New issues + +Send us a message on https://discord.com/channels/665254494820368395/983769458269114408[Discord]! diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting/index.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/index.adoc new file mode 100644 index 000000000..521ac364e --- /dev/null +++ b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/index.adoc @@ -0,0 +1,39 @@ += Troubleshooting + +This section provides general recommendations and solutions to common issues faced while interacting with TypeDB. + +Please refer to the section closest to your problem. +If you cannot find a solution, do not hesitate to send us a message on https://discord.com/channels/665254494820368395/983769458269114408[Discord]! + +[cols-2] +-- +.xref:{page-version}@new_maintenance_operation::troubleshooting/installation.adoc[] +[.clickable] +**** +Addressing setup issues. +**** + +.xref:{page-version}@new_maintenance_operation::troubleshooting/connection.adoc[] +[.clickable] +**** +Resolve connection issues. +**** + +.xref:{page-version}@new_maintenance_operation::troubleshooting/stopping-queries.adoc[] +[.clickable] +**** +Query takes too long. +**** + +.xref:{page-version}@new_maintenance_operation::troubleshooting/optimising-queries.adoc[] +[.clickable] +**** +Optimize your queries for the best performance. +**** + +.xref:{page-version}@new_maintenance_operation::troubleshooting/debugging-queries.adoc[] +[.clickable] +**** +Tips for query debugging. +**** +-- diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting/installation.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/installation.adoc new file mode 100644 index 000000000..d81186cb1 --- /dev/null +++ b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/installation.adoc @@ -0,0 +1,26 @@ += Installation + +== GLIBC not found + +*The server does not start with error `version 'GLIBC_2.25' not found`* + +TypeDB for Linux currently requires glibc v2.25 or later. Updating your Linux distribution may resolve this issue. + +Supported versions of some popular Linux distributions: + +* Debian 10 buster or newer, +* Ubuntu 17.10 artful or newer, +* RHEL-8.10 or newer, +* Fedora 26 or newer, +* CentOS 8.5 or newer, +* Amazon Linux 2, +* Amazon Linux 2023. + +If your distribution is not listed above, you can consult https://distrowatch.com/[DistroWatch.com] to find out if +the newest version ships with glibc >=2.25. + +TIP: Alpine Linux does not ship with glibc by default. Additional setup is required to run TypeDB server on Alpine Linux. + +== New issues + +Send us a message on https://discord.com/channels/665254494820368395/983762496798204024[Discord]! diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting/optimising-queries.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/optimising-queries.adoc new file mode 100644 index 000000000..c555eb8d9 --- /dev/null +++ b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/optimising-queries.adoc @@ -0,0 +1,119 @@ += Optimizing queries + +== TypeDB's optimizer + +The built-in optimizer of TypeDB will decide the optimal order of evaluation of your query on a *per-stage* basis, while also respecting the boundaries of subqueries (created via `or`, `not`, or function calls). This gives user direct control over the evaluation order in their queries. For example, the query + +[,typeql] +---- +match + $x isa user; + $x has username "john_1"; +---- +and the query pipeline + +[,typeql] +---- +match + $x isa user; +match + $x has username "john_1"; +---- +are semantically equivalent (i.e., they yield the same results), but the first query will likely run much faster than the second query. + +1. In the first query, the optimizer will optimize evaluation order of the first (and only) `match` stage: it'll decide that it is most efficient to first look up all entities with `username` equal to `"john_1"` and then filter the result to contain only `user` entities. +2. The second query comprises two stages, to be executed one after the other: the database will first retrieve _all_ users, thus constructing a very large set of answers. Only in the second stage to we filter this set to contain only users with `username` equal to `"john_1"`. + +In other words, the second query suffers from having _large intermediate results_. + +== Avoiding large intermediate results + +A standard method for avoiding large intermediate results is to declare/enforce constraints as early as possible: this is also known as *predicate-pushdown*. The above queries provide an example of this principle. + +In TypeQL predicate-pushdown is extended to the principle of *data-predicate-locality*: create data only at the stage where you need it, jointly with all applicable predicates. Pipelines give you fine-grained control to ensure that data is created where you need it. For example, a schematic pipeline of the form: +[,typeql] +---- + + + +---- +could be rewritten to be of the form +[,typeql] +---- + + + + +---- +This defers matching of data to be stored in the variables `$a` until after we have finished processing `$b` (assuming the latter is fully independent of results for `$a`). + +== Optimizing branches + +Another source of suboptimality in queries comes from the usage of `or`-branches, and could be called *pattern-pushdown*. TypeDB performs minimal transformation of your `or`-branches, assuming that each disjunction is meant to be a *branching point* of your query, at which a set of nested subqueries is retrieved. + +Thus, when working with branches, we should ensure that data is retrieved a minimal number of times. Schematically, this can be understood as follows: the query +[,typeql] +---- +match + ; + { ; ; } + or { ; ; } + or { ; }; +---- +is equivalent to the pattern +[,typeql] +---- +match + ; + { + ; + { ; } or { ; }; + } or { + ; + }; +---- +We expect the second query to run faster, as it evaluates the `` only in one subquery (which itself has two further subqueries). + +== Optimizing negations + +Negations, especially nested negations, can be extremely expensive query operations: indeed, to ensure that something does not exist, we usually must search the entire domain of possibilities. It is therefore paramount to reduce the "`size of the domain`" prior to using negation. For example, the query +[,typeql] +---- +match + $x isa user; + not { + $y isa user; + not { friendship ($x, $y) }; + }; +limit 1; +---- +does the following: + +> Find me a user `$x` for which there does not exist a user `$y` that is not friends with `$x`. + +This can equivalently be achieved by the following query: +[,typeql] +---- +match + $x isa user; + friendship ($x, $y); +reduce $f_count = count groupby $x; +sort $f_count desc; +limit 1; +match $f_count == user_count(); # function returning user count +---- +While the first query needs to consider data whose size is quadratic in the number of users, the second query considers data linear in the size of friendships. + +== Optimizing recursive functions + +[NOTE] +==== +Coming soon. +==== + +== Roadmap + +[NOTE] +==== +While the above advice is timeless in any case, future versions of TypeDB may apply more aggressive query transformation techniques that will shift the burden of optimizing nested subqueries from the user further to the database. +==== \ No newline at end of file diff --git a/new_maintenance_operation/modules/ROOT/pages/troubleshooting/stopping-queries.adoc b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/stopping-queries.adoc new file mode 100644 index 000000000..bf2d9d582 --- /dev/null +++ b/new_maintenance_operation/modules/ROOT/pages/troubleshooting/stopping-queries.adoc @@ -0,0 +1,35 @@ += Stopping queries + +If a query runs indefinitely, you may need to stop it. +This page provides general guidelines for safely terminating queries in different TypeDB clients. + +[#query_interruption] +== Is it safe to interrupt queries? + +Yes. +Read queries do not alter the database and can be stopped safely at any time. +Schema and write queries also do not affect the database until they are <>, making it safe to terminate them as well. + +== Transaction close + +The main way to interrupt a misbehaving query is to close the transaction. + +Every transaction also opens with a default transaction timeout, which is 5 minutes. After the timeout, the server will automatically close the transaction. This provides some protection against both resource leaks (forgetting to close the transaction), and queries running for too long. + +== Stop a query through TypeDB clients + +[NOTE] +==== +Currently, queries cannot be stopped from the client while execution runs on the server. (Leave us a note if this is an issue for you!) +==== + +== Nothing works? + +If other methods fail, you can stop or kill the server. +The recovery mechanism will resolve any disruptions caused by this action, ensuring that the server restarts as a fully functional TypeDB instance with no corruption. + +[#commit_interruption] +== Is it safe to interrupt commits? + +Yes. +Interrupting a commit process in any way (e.g., by killing the server) is handled by the recovery mechanism. The database will remain in the correct state it was in before the commit, ensuring data integrity. diff --git a/new_maintenance_operation/modules/ROOT/pages/typedb-backups.adoc b/new_maintenance_operation/modules/ROOT/pages/typedb-backups.adoc index 774ebbdce..29f6dde8c 100644 --- a/new_maintenance_operation/modules/ROOT/pages/typedb-backups.adoc +++ b/new_maintenance_operation/modules/ROOT/pages/typedb-backups.adoc @@ -1,10 +1,10 @@ = TypeDB Backups -This documentation covers the backup solutions available for TypeDB, both in the Cloud and Self-hosted environments. +This documentation covers the backup solutions available for TypeDB, both in the Cloud and Self-hosted CE and Enterprise deployments. == Cloud Backups -TypeDB Cloud provides robust backup capabilities leveraging the underlying cloud provider's disk snapshot capabilities. +TypeDB Cloud provides robust backup capabilities that can be automated and configured to suit your needs. === Automated Backups @@ -30,15 +30,14 @@ When restoring from a backup, you have two options: == Self-hosted Backups For self-hosted TypeDB deployments, backup implementation is the responsibility of the user. -We recommend using either disk snapshots (similar to the Cloud offering) or our import/export tool: +We recommend using either disk snapshots or our import/export tool. Neither of these options are incremental. -=== Disk Snapshots +=== Export/Import -Similar to the Cloud offering, you can use your infrastructure's disk snapshot capabilities. -This provides a backup of the database state at a point in time, and can be used to restore to a previous state. +Use the xref:{page-version}@new_maintenance_operation::database-export-import.adoc[] tool for exporting and importing database state. -=== Export/Import +Doing an `export` will provide you with two files - one representing the schema, and the other representing the data. These can then be used with `import` to restore the database to the point when the export was taken. + +=== Disk Snapshots -xref:{page-version}@new_tools::console.adoc[TypeDB Console] provides a tool for exporting and importing database state. -Doing an `export` will provide you with two files - one representing the schema, and the other representing the data. -These can then be used with `import` to restore the database to the point when the export was taken. +It's possible take snapshots using a cloud provider's disk snapshot utility, and create a new TypeDB server instance based on the snapshotted disk. This can be done while the server is running. diff --git a/new_maintenance_operation/modules/ROOT/pages/typedb-upgrades.adoc b/new_maintenance_operation/modules/ROOT/pages/typedb-upgrades.adoc index 8946112aa..8e61e2ef8 100644 --- a/new_maintenance_operation/modules/ROOT/pages/typedb-upgrades.adoc +++ b/new_maintenance_operation/modules/ROOT/pages/typedb-upgrades.adoc @@ -1,4 +1,18 @@ = TypeDB Upgrades -[placeholder] -Upgrade TypeDB servers. \ No newline at end of file +There are two mechanisms in which data can be preserved during a server version upgrade: + +* If the new version has the same data format as the old one, it should be done by reusing or copying the data directory. +* Otherwise, it should be done by using the xref:{page-version}@new_maintenance_operation::database-export-import.adoc[] tool, which would take care of migrating the data into the new format. + +== Preserve data by copying the directory + +To do this, simply shut down the servers of the old version, and copy the database to migrate from the data directory (set with the `--storage.data` command line argument) into the data directory of the new TypeDB server installation. + +Alternatively, just start the new server making sure it uses the same +*data directory* path as the old one. + +[#_export_and_import] +== Preserve data using the export/import tool + +See the page on xref:{page-version}@new_maintenance_operation::database-export-import.adoc[]. diff --git a/new_maintenance_operation/modules/ROOT/partials/nav.adoc b/new_maintenance_operation/modules/ROOT/partials/nav.adoc index c14f797ec..8ed75b737 100644 --- a/new_maintenance_operation/modules/ROOT/partials/nav.adoc +++ b/new_maintenance_operation/modules/ROOT/partials/nav.adoc @@ -10,4 +10,9 @@ * xref:{page-version}@new_maintenance_operation::database-export-import.adoc[] -* xref:{page-version}@new_maintenance_operation::troubleshooting.adoc[] +* xref:{page-version}@new_maintenance_operation::troubleshooting/index.adoc[] +** xref:{page-version}@new_maintenance_operation::troubleshooting/installation.adoc[] +** xref:{page-version}@new_maintenance_operation::troubleshooting/connection.adoc[] +** xref:{page-version}@new_maintenance_operation::troubleshooting/stopping-queries.adoc[] +** xref:{page-version}@new_maintenance_operation::troubleshooting/optimising-queries.adoc[] +** xref:{page-version}@new_maintenance_operation::troubleshooting/debugging-queries.adoc[] diff --git a/new_tools/modules/ROOT/pages/console.adoc b/new_tools/modules/ROOT/pages/console.adoc index 807cdbcd2..d6c02795b 100644 --- a/new_tools/modules/ROOT/pages/console.adoc +++ b/new_tools/modules/ROOT/pages/console.adoc @@ -1,14 +1,12 @@ = TypeDB Console -[.float-group] --- TypeDB Console is a standalone TypeDB client with a command line interface (CLI). It serves as a lightweight and powerful CLI tool to manage and query TypeDB databases. Console is the default client distributed with TypeDB, but it can also be installed separately. [NOTE] ==== -For installation instructions, see xref:{page-version}@new_home::install/studio-console.adoc[Studio & Console Installation]. +For installation instructions, see the xref:{page-version}@new_home::install/studio.adoc[] install page. ==== == Connect to TypeDB @@ -163,10 +161,7 @@ Where `` is the path to the file and the filename. == Run query(ies) from a file -To run a series of TypeQL queries stored in a file from _within_ a REPL, use the `source ` command. -Each query should be separated with an empty newline. -Note that this means long queries cannot be split over multiple lines containing empty lines. -Use comments instead. +To run a series of TypeQL queries stored in a file from _within_ a REPL, use the `source ` command. Each query should be separated with an `end;` statement and a newline. Multi-clause queries over multiple lines are considered one pipeline until an `end;` clause is encountered or the query unambiguously ends (such as a `fetch` clause). This command is available from the Transaction level REPL: @@ -227,12 +222,15 @@ or run https://docs.microsoft.com/en-us/windows-server/administration/windows-co Most systems also allow us to set the system-wide locale. However, this impacts the appearance of other applications. +[#_references] == References +[#_command_line_arguments] === Console CLI arguments The following arguments can be used when invoking TypeDB Console: +.Command line arguments [cols=".^3,^.^1,5"] |=== ^| Argument ^| Alias ^| Description @@ -246,11 +244,11 @@ Note that by default, TLS is enabled, which will require an `https://` endpoint. | `--username=` | -| Username. +| Username. + | `--password=` | -| Explicitly pass in the password (not recommended). Interactive sessions should let the console safely request for the password. +| Explicitly pass in the password (not recommended). Interactive sessions should let the console safely request for the password. + | `--tls-disabled` | @@ -259,17 +257,176 @@ Typically used for development or local work. **When using this option, username | `--tls-root-ca=` | -| Path to the root CA certificate file for TLS connections. +| Path to the TLS root CA file, when the server is using self-managed certificates. + -| `--command=` +| `--command=` | -| Execute a command and exit. Can be used multiple times. +| Commands to run in the Console, without interactive mode. Repeated invocations will be run in the order provided. -| `--script=` +| `--script=