LeanXcale v2.2 User’s Guide
This document is the User’s guide for the leanXcale system administrator.
- 1. Background
- 2. Start and Stop Particularities on Different Installs
- 3. Licenses
- 4. Licenses at LeanXcale
- 5. Starting the System
- 6. Bare Metal Starts at LeanXcale
- 7. Checking System Status
- 8. Stopping the System
- 9. System Recovery
- 10. Running SQL Queries
- 11. Configuring the System
- 12. System Logs
- 13. Backups
- 14. Adding Hosts on LeanXcale Installs
- 15. Reporting Issues
1. Background
1.1. LeanXcale Components
Before installing, it is important to know that LeanXcale has a distributed architecture and it consists of several components:
-
lxqe: Query engine in charge of processing SQL queries.
-
kvds: Data server of the storage subsystem. There might be multiple instances.
-
kvms: Metadata server of the storage subsystem.
-
lxmeta: Metadata process for LeanXcale. It keeps metadata and services needed for other components.
-
stats: Optional monitoring subsystem to see resource usage and performance KPIs of LeanXcale database.
-
odata: Optional OpenDATA server to support a SQL REST API.
There are other components used by the system, that
are not relevant for the user and are not described here. For example,
spread
is a communication bus used by LeanXcale components.
1.2. LeanXcale Commands
The command lx
is a
Shell for running LeanXcale control programs. This simply fixes the
environment for the installed host and runs the command given as an
argument:
usage: lx [-d] cmd...
The command operates on the whole LeanXcale system, even when multiple hosts are used.
It is convenient to have lx
in the PATH
environment variable, as
suggested in the install program output.
Command output usually includes information on a per-host basis reporting the progress of the used command.
Most commands follow the same conventions regarding options and arguments. We describe them here as a convenience.
Arguments specify what to operate (e.g., what to start, stop, etc.) may be empty to rely on the defaults (whole DB) or may specify a particular host and/or component name:
-
when only component names are given, and only those components will be involved (e.g.,
lxqe101
). -
when a component type name is given, components for that type are selected. (e.g.,
lxqe
). -
when a host name is given, any component following is narrowed to that host. If no components follow the host name, all components from the host are selected.
This may be repeated to specify different hosts and/or components.
The special host names db
, repl
, and repl2
may be used and
stand for hosts without the nodb
attribute, hosts for the first
replica, and hosts for the second replica (hosts that are a mirror of
other ones).
1.2.1. LeanXcale Commands on Bare Metal Installs
For bare metal installs, it suffices to have the lx
command in the PATH.
It can run on any of the installed hosts.
For example, on an installed host, lx version
prints the installed version:
unix$ lx version leanXcale v2.2 kv v2.2.2023-09-29.115f5fba70e3af8dc203953399088902c4534389 QE v2.2.2023-09-30.1e5933900582.26a7a5c3420cd3d5d589d1fa6cc libs v2.2.2023-09-29.67535752acf19e092a6eaf17b11ad17597897956 avatica v2.2.2023-09-27.0b0a786b36e8bc7381fb2bb01bc8b3ed56f49172 TM v2.2.2023-09-29.9a9b22cfdc9b924dbc3430e613cddab4ed667a57
1.2.2. LeanXcale Commands on Docker Installs
To use the lx
command on a docker install, an installed container must be
running, and the command must be called on it.
For example, assume that the container named lx1
is running on a Docker install.
The container could be started using the following command,
assuming the leanXcale image is named lx:2
, and the docker network used is
lxnet
:
unix$ docker run -dit --name lx1 --network lxnet -p0.0.0.0:14420:14420 lx:2 lx1 b28d30702b80028f8280ed6c55297b2e203540387d3b4cfbd52bc78229593e27
It is possible to attach to the container and use the ''lx'' command as it can be done on a bare metal host install:
unix$ docker attach lx1 lx1$ lx version ...
Here, we type docker attach lx1
on the host, and lx version
on
the docker container prompt.
Note that if you terminate the shell reached when attaching the docker container, it will stop. Usually, this is not desired.
It is possible to execute commands directly on the executed container. For example:
unix$ docker exec -it lx1 lx version
executes lx version
on the lx1
container.
In what follows, lx1
is used as the container name in the examples for docker
installs.
1.2.3. LeanXcale Commands on AWS Installs
Using lx
on AWS hosts is similar to using it on a bare-metal install.
The difference is that you must connect on the AWS instance to run the command
there.
For example, after installing xample.aws.leanxcale.com
, and provided the
PEM file can be found at xample.pem, we can run this:
unix$ ssh -i xample.pem xample.aws.leanxcale.com lx version
to see the installed version.
In what follows, xample.pem
is used as the PEM file name
and xample.aws.leanxcale.com
is used as the installed instance name,
for all AWS install examples.
2. Start and Stop Particularities on Different Installs
System start depends on how the system has been installed. For bare-metal installations, the administrator installing the system is responsible for adding a system service that brings LeanXcale into operation when the machine starts, and stops LeanXcale before halting the system.
For AWS installations, starting the instance starts the LeanXcale service, and stopping the instance stops LeanXcale before the instance stops.
For Docker installations, starting a container starts the LeanXcale service on it, and, for safety, LeanXcale should be halted before halting the container (otherwise Docker might decide to time-out and stop the container before LeanXcale did fully stop).
3. Licenses
To check for license status or to install a new license you can use the lx license
command.
For a local installation, use just
unix$ lx license license expires: Mon Dec 30 00:00:00 2024
For docker installs, each container must include its own license. The DB in the container does not start the DB unless a valid license is found. But, the container must be running to check the license status and to install new licenses. Refer to the section on starting docker containers for help on that.
For example, to list the license status for the container lx1
we can run
unix$ docker exec -it lx1 lx license lx1 [ kvcon[1380]: license: no license file failed: failed: status 1 ] failed: status 1
To install a new license, just copy the license file to the container as shown here
unix$ docker cp ~/.lxlicense lx1:/usr/local/leanxcale/.lxlicense unix$ docker exec -it lx1 sudo chown lx /usr/local/leanxcale/.lxlicense
The license status should be ok now:
unix$ docker exec -it lx1 lx license license expires: Mon Dec 30 00:00:00 2024
4. Licenses at LeanXcale
You can run the kvlicense
file to generate a license file:
unix$ kvlicense usage: kvlicense yymmdd file unix$ kvlicense 243012 lxlicense kvlicense[34951]: license saved at lxlicense with limit Fri Jun 12 2026
This binary is not built by default and is not included in the distribution Ask for help if you need it.
5. Starting the System
5.1. Bare Metal System Start
The start
command starts LeanXcale:
unix$ lx start start... atlantis [ cfgile: /ssd/leandata/xamplelx/lib/lxinst.conf... bin/spread -c lib/spread.conf ... forked bin/spread... bin/spread: started pid 1056053 bin/kvms -D 192.268.1.224!9999 /ssd/leandata/xamplelx/disk/kvms100/kvmeta ... forked bin/kvms... ... ] atlantis [ kvds103 pid 1056084 alive kvms100 pid 1056057 alive spread pid 1056053 alive kvds102 pid 1056075 alive kvds100 pid 1056062 alive kvds101 pid 1056066 alive ] unix$
Here, atlantis
started a few processes and, once done, the start
command checked out if the processes are indeed alive.
In case not all components can be started successfully, the whole LeanXcale system is halted by the start command.
To start a single host or component, use its name as an argument, like in:
# start the given host unix$ lx start atlantis # start the named components unix$ lx start kvds # start the named components at the given host unix$ lx start atlantis kvds
Start does not wait for the system to be operational. To wait until the
system is ready to handle SQL commands, the status
command can be
used with the -w
(wait for status) flag, as in:
unix$ lx status -w running status: running
Without the -w
flag, the command prints the current status, which
can be stopped, failed, running, or waiting.
5.2. Docker System Start
To start LeanXcale installed on Docker containers, you must start the containers holding the installed system components.
For example, consider the default docker install
unix$ lxinst docker ... install done docker images: REPOSITORY TAG IMAGE ID CREATED SIZE uxbase 2 7c8262008dac 3 months ago 1.07GB lx 2 cafd60d35886 3 seconds ago 2.62GB docker network: NETWORK ID NAME DRIVER SCOPE a8628b163a21 lxnet bridge local to start: docker run -dit --name lx1 --network lxnet lx:2 lx1
The install process created a docker image named lx:2
, installed for the docker
host lx1
, and the docker network lxnet
.
To list the image we can
unix$ docker images lx REPOSITORY TAG IMAGE ID CREATED SIZE lx 2 75b8c9ffa245 About a minute ago 2.62GB
And, to list the networks
unix$ docker network ls NETWORK ID NAME DRIVER SCOPE a8628b163a21 lxnet bridge local
The created image is a single one for all containers. The name given when creating the container determines the host name used The install process specified the host names, and containers must be starte using the corresponding host name(s), so they know which leanXcale host they are for.
For example, to start the container for lx1
:
unix$ docker run -dit --name lx1 --network lxnet -p0.0.0.0:14420:14420 lx:2 lx1 b28d30702b80028f8280ed6c55297b2e203540387d3b4cfbd52bc78229593e27
In this command, the container name is lx1
, the network used
lxnext
, and the image used lx:2
. The port redirection -p…
exports the SQL port to the underlying host.
Listing docker processes shows now the running container
unix$ docker ps CONTAINER ID IMAGE COMMAND STATUS PORTS NAMES e81d9d01f40a lx:2 "/bin/lxinit lx1" Up 56 seconds 14410 lx1
It is important to know that:
-
starting the container will start leanXcale if a valid license was installed;
-
stopping the container should be done after stopping leanxcale in it.
The container name (lx1
) can be used to issue commands. For example,
unix$ docker exec -it lx1 lx version leanXcale v2.1 unstable kv v2.1.2.14-02-15.c26f496706918e610831c02e99da3676a1cffa47 lxhibernate v2.1.2.14-02-07.f65c5a628afede27c15c77df6fbbccd6d781d3ee TM v2.1.2.14-02-06.bfc9f92216481dd05f51900ac522e5ccfb6d2555 QE v2.1.2.14-02-15.4a8ff4200dc3d3656c8469b6f74c05a296fbdfb3 avatica v2.1.2.14-02-14.1c442ac9e630957ace3fdb5c4faf92bb85510099 ...
executes lx version
on the lx1
container.
The status for the system can be seen in a similar way:
unix$ docker exec -it lx1 lx status status: running
Note that the container will not start the DB if no valid license is found.
5.3. AWS System Start
To start LeanXcale installed on AWS, you must start the AWS instances holding the installed system components.
Once started, the lx
command is available at any of the installed system
instances.
For example, after statring xample.aws.leanxcale.com
, and provided the
PEM file can be found at xample.pem, we can run this:
unix$ ssh -i xample.pem xample.aws.leanxcale.com lx version
to see the installed version.
6. Bare Metal Starts at LeanXcale
When using replication, you can start one of the replicas (1 or 2):
unix$ lx start repl1
This addressing scheme can be used in many other commands. See the
reference for the lx
command later in this document for a full
description of addressing.
7. Checking System Status
7.1. Bare Metal System Status
The command lx status
reports the status for the system
or waits for a given status.
For example,
unix$ lx status status: waiting kvds100: recovering files kvds101: recovering files
Or, to wait until the status is running
:
unix$ lx status -v -w running status: waiting kvds100: recovering files kvds101: recovering files status: running unix$
To see the status for each one of the processes in the system, use lx procs
.
For example:
unix$ lx procs procs... atlantis [ kvds103 pid 1057699 alive running kvms100 pid 1057672 alive running spread pid 1057668 alive kvds102 pid 1057690 alive running kvds100 pid 1057677 alive running kvds101 pid 1057681 alive running ]
7.2. Docker System Status
Before looking at the LeanXcale system status, it is important to look at the status of the docker containers running LeanXcale components.
unix$ docker ps CONTAINER ID IMAGE COMMAND STATUS PORTS NAMES e81d9d01f40a lx:2 "/bin/lxinit lx1" Up 56 seconds 14410 lx1
When containers are running,
the command lx status
reports the status for the system
or waits for a given status.
For example,
unix$ docker exec -it lx1 lx status
executes lx status
on the lx1
container.
The status is reported for the whole system, and not just for that container.
To wait until the status is running
:
unix$ docker exec -it lx1 lx status -v -w running status: waiting kvds100: recovering files kvds101: recovering files status: running
To see the status for each one of the processes in the system, use lx procs
.
For example:
unix$ docker exec -it lx1 lx procs procs... atlantis [ kvds103 pid 1057699 alive running kvms100 pid 1057672 alive running spread pid 1057668 alive kvds102 pid 1057690 alive running kvds100 pid 1057677 alive running kvds101 pid 1057681 alive running ]
7.3. AWS System Status
Before looking at the LeanXcale system status, it is important to look at the status of the AWS instances running LeanXcale components.
When instances are running,
the command lx status
reports the status for the system
or waits for a given status.
For example,
unix$ ssh -i xample.pem xample.aws.leanxcale.com lx status
to see the system status.
To wait until the status is running
:
unix$ ssh -i xample.pem xample.aws.leanxcale.com lx status -v -w running status: waiting kvds100: recovering files kvds101: recovering files status: running
To see the status for each one of the processes in the system, use lx procs
.
For example:
unix$ ssh -i xample.pem xample.aws.leanxcale.com lx procs procs... atlantis [ kvds103 pid 1057699 alive running kvms100 pid 1057672 alive running spread pid 1057668 alive kvds102 pid 1057690 alive running kvds100 pid 1057677 alive running kvds101 pid 1057681 alive running ]
8. Stopping the System
8.1. Bare Metal System Stop
The stop
command halts LeanXcale:
unix$ lx stop stop... atlantis [ kvcon[1056801]: halt ] atlantis [ term 1056062 2056066 1056075 1056084 1056057 1056053... kill 1056062 2056066 1056075 1056084 1056057 1056053... ] unix$
8.2. Docker System Stop
Stopping the LeanXcale containers should be done after stopping leanxcale. The reason is that docker might timeout the stop operation if the system is too busy updating the disk during the stop procedure.
To stop the database,
unix$ docker exec -it lx1 lx stop
stops the components for the whole system (being lx1
an installed container).
We can double check this
unix$ docker exec -it lx1 lx status status: stopped
Once this is done, we can stop the docker container.
unix$ docker ps CONTAINER ID IMAGE COMMAND STATUS PORTS NAMES e81d9d01f40a lx:2 "/bin/lxinit lx1" Up 56 seconds 14410 lx1
unix$ docker stop lx1 lx1
unix$ docker ps unix$
We can also remove the container, but, note that doing this removes all data in the container as well.
unix$ docker rm lx1 lx1 unix$
9. System Recovery
The lxmeta
component watches the status for other components and will stop
the system when there is a failure that cannot be recovered online.
Should the system crash or fail-stop, upon a system restart, lxmeta
will
guide the system recovery.
At start time, each system component checks out its on-disk information and decides to start either as a ready component or as a component needing recovery.
The lxmeta
process, guides the whole system start process following these steps:
-
Wait for all required components to be executing.
-
Look up the component status (ready/recovering).
-
If there are components that need recovery, their recovery process is executed.
-
After all components are ready, the system is made available by accepting queries.
The command lx status
can be used both to inspect the system status and the
recovering process, or to wait until the recovery process finishes and the system
becomes available for queries.
10. Running SQL Queries
To use the database with the standard SQL client, you can use this command supplying the user name and secret:
unix$ lx sql -n lxadmin -p **** lx% !tables ...
It is suggested not to give the password in the command line, but to
open the connection later within the sql
prompt, to prevent listing
the password in the process list for the underlying password. This was
just an example.
The isolation model can be set using the -M
argument, as in:
unix$ lx sql -Msession -n lxadmin -p **** lx% !tables ...
LeanXcale isolation levels are (from strongest to weakest):
-
session_consistency or session: the transaction has as snapshot then one incorporating the changes from the last update transaction in the same session.
-
snapshot_isolation or si: standard snapshot isolation, that is, when the transaction starts gets the current snapshot and all reads are performed over that snapshot.
-
read_committed or rc: each SQL statement gets the current snapshot and reads are performed from that snapshot.
-
raw_read_committed or rawrc: each read performed by an SQL statement get the latest committed value.
-
loader: Special isolation level to accelerate database loads. It is like read committed but it does not perform conflict detection nor logging. This can only be done without any other transactions accessing the database.
Communication between the SQL client and the query engine(s) is not encrypted by
default.
Install using the tls
property to ask for encrypted communications.
The lx sql
command does this on its own, but,
when using a connection URL on a standard JDBC client, add the
tls=yes
property to the connection property set. This tells the leanXcale client driver to use TLS.
11. Configuring the System
The lx config
command prints or updates the configuration used for the
LeanXcale system:
unix$ lx config cfgile: /usr/local/leanxcale/lib/lxinst.conf... #cfgfile /usr/local/leanxcale/lib/lxinst.conf host localhost lxdir /usr/local/leanxcale JAVA_HOME /usr/lib/jvm/java-1.11.0-openjdk-amd64 addr 127.0.0.1 odata 100 addr localhost!14004 kvms 100 addr 127.0.0.1!14400 lxmeta 100 addr 127.0.0.1!16500 lxqe 100 addr 127.0.0.1!16000 kvds 100 addr 127.0.0.1!15000 kvds 101 addr 127.0.0.1!15002 kvds 102 addr 127.0.0.1!15004 kvds 103 addr 127.0.0.1!15006
The configuration printed provides more details than the configuration file (or command line arguments) used to install.
NB: when installing into AWS or docker, the configuration printed
might lack the initial aws
or docker
property used to install it.
It is possible to ask for particular config entries, like done here:
unix$ lx config kvms addr
It is also possible to adjust configured values, like in
unix$ lx config -s lxqe mem=500m
used to adjust the lxqe
mem
property to be 500m
in all lxqe
components configured.
12. System Logs
Logs are kept on a per-system directory, named log
, kept at the install
directory for each system.
Log files have names similar to
kvms100.240214.1127.log
Here, the component name comes first, and then, the date and time when the log file was created. When a log file becomes too big, a new one is started for the given component.
It is convenient to use the lx logs
command to list and inspect logs.
It takes care of reaching the involved log files on the involved hosts.
For example, to list all log files:
unix$ lx logs logs... atlantis: [ log/kvds100.240214.1127.log 250.00K log/kvms100.240214.1127.log 35.39K log/lxmeta100.240214.1127.log 24.10K log/lxqe100.240214.1127.log 445.80K log/spread.240214.1127.log 963 log/start.log 426 ]
Here, atlantis
was the only system installed.
We can give host and/or component names as in many other commands to focus on those systems and/or components.
For example, to just just logs for kvms
processes:
unix$ lx logs kvms logs... atlantis: [ log/kvms100.240214.1127.log 35.39K ]
Or, to list only those for the kvms100
:
unix$ lx logs kvms100
To list logs for the atlantis
host:
unix$ lx logs atlantis
To list logs for kvms
components within atlantis
:
unix$ lx logs atlantis kvms
To list logs for kvms
components at atlantis
and kvds
at orion
:
unix$ lx logs atlantis kvms orion kvds
With flag -p
, logs are printed in the output instead of being listed.
unix$ lx logs -p lxmeta atlantis: [ log/lxmeta100.240214.1127.log 24.10K [ # pid 3351755 cmd bin/javaw com.leanxcale.lxmeta.LXMeta -a atlantis!14410 ...
Flag -g
greps the logs for lines with the given expression.
For example:
unix$ lx logs -g fatal
And, flag -c
copies the logs to the given directory
unix$ lx logs -c /tmp
When printing and copying the logs, only the last log file for each component
are used.
To operate on all the logs and not just on the last one, use flag -a
too:
unix$ lx logs -a -c /tmp
13. Backups
Backups can be made to a external location (recommended to tolerate disk failures)
or within an installed host.
External backups (i.e., to an external location) are made using the lxbackup
tool,
installed at the bin
directory, which works with a given configuration file.
Internal backups (i.e., to a directory on installed hosts) are made using the lx backup
command.
Using lxbackup
is exactly like using lx backup
with a few
differences:
-
Flag
-f
is mandatory and must be used to provide the installed configuration file. -
The default backup directory is not
$LXDIR/dump
, but./lxdump
.
By default, internal backups (lx backup
),
the backup is $LXDIR/dump
at the host used to issue
backup commands. The convention is to use the first host to keep
backups.
The lxbackup
command can be found at the installed $LXDIR/bin
directory on any installed host. If you are not sure regarding the
$LXDIR
value, use this command to find it:
unix$ lx -d pwd /usr/local/leanxcale unix$
Flag -d
for lx
makes it change to the $LXDIR
directory
before running the given command.
The detailed configuration file to be used with lxbackup
is created at lxinst.conf
when installing. The configuration can be retrieved also by the
lx config
command. For example:
unix$ lx config -o lxinst.conf saved lxinst.conf
On external backups, the backup directory is ./dump
unless otherwise specified
to the backup command.
This directory can be a mount point or a link to a remote directory to keep backups at a different machine.
Directories under dump/
are named using the date, with .1
,
.2
, etc. appended if more than one backup is created on the same
date. If the backup is incremental, a final +
is added to the
directory name.
For example, create a full, cold, backup on the installed system (e.g., atlantis
)
when leanXcale is not running:
unix$ lx backup backup... host atlantis... backup: /usr/local/leanxcale/dump/230720 unix$
The printed path is the path for the directory keeping the backup, as used when restoring it.
This backup is not encrypted and is not compressed.
Flag -z
gzips backed up files, and flag -C
also encrypts them.
These flags are also used when restoring a backup.
For example, this behaves like the previous example, but encrypts and compresses the backup
unix$ lx backup -C backup... host atlantis... backup: /usr/local/leanxcale/dump/230720 unix$
To setup the external host orion
for backups, copy the backup
program and save and copy the installed configuration:
unix$ lx config -o lxinst.conf saved lxinst.conf unix$ lx -d pwd /usr/local/leanxcale unix$ scp /usr/local/leanxcale/bin/lxbackup lxinst.conf orion:~
And then, to create a full, ecnrypted, cold, backup on orion
:
orion$ lxbackup -C -f lxinst.conf backup... host atlantis... backup: lxdump/230720 ... orion$
In the examples that follow, orion
is used as the external backup host.
An important note is that file modification times are preserved in backup files. They are used to learn if a file must be copied or not in an incremental backup. If a backup is relocated to a different place, and later copied back into the standard location, preserve file modification times in the process.
Using flag -z
makes the tool gzip
backup files, preserving
modification times despite compression.
13.1. Cold Incremental Backups
Flag -i
performs an incremental backup, made with respect to the last total backup
made on the same backup location.
This is done after the system is stopped. The system should not be running while doing a cold backup.
For example, from the external backup host in the running example:
orion$ lxbackup -i -f lxinst.conf backup... host atlantis... ... orion$
Or, from the installed system backup in our example:
unix$ lx backup -i backup... host atlantis... backup: dump/230720.3+ ... unix$
The system should not be running while doing a cold backup.
Remember to use flag -z
or flag -C
if the backups made were compressed or encrypted.
13.2. Hot Incremental Backups
To perform a hot backup, backup the redo logs as an incremental dump by specifying lxqe:
orion$ lxbackup -i -f lxinst.conf lxqe backup... host atlantis... backup: dump/230720.4+ ... orion$
Remember to use flag -z
or flag -C
if the backups made were compressed or encrypted.
For example,
orion$ lxbackup -C -i -f lxinst.conf lxqe
is the command if backups at this place are encrypted.
13.3. Listing Backups
With flag -p
, both lxbackup
and lx backup
list the known backups:
unix$ lx backup -p backup... /usr/local/leanxcale/dump/230720 /usr/local/leanxcale/dump/230720.1+ /usr/local/leanxcale/dump/230720.2 encrypted ...
Those with a +
in their names are incremental backups.
Those encrypted are reported as such.
13.4. Removing Old Backups
To remove a backup, it suffices to remove its directory. For example:
unix$ lx -d rm -rf dump/230720.2
Here we used the flag “-d” for lx
to change to $LXDIR
before
executing the remove command, which makes it easy to name the directory
used for the dump.
Or, from our external backup example host:
orion$ rm -rf dump/230720.2
Beware that if you remove a backup, you should remove those incremental backups that follow up to the next total backup.
13.5. Restore
To restore a backup, use the -r
flag for lxbackup
or lx backup
and name
the backup directory to restore.
For example, this restores the given full backup path:
orion$ lxbackup -f lxinst.conf -r lxdump/230720 ...
Do this while the system is stopped.
To restore an incremental backup (and therefore, all previous incremental backups and the total backup made before them), supply an incremental backup path.
This restores the previous total backup made and the incremental backups that follow up to the given one.
14. Adding Hosts on LeanXcale Installs
To add more hosts to a existing install, edit the configuration file to add the extra hosts. The command:
unix$ lx config
can print the configuration if it is no longer available.
Once the new host(s) are added, run the install program to update the new hosts (and install them):
unix$ lxinst -u -f lxinst.conf
And finally, start the DB on the new host(s). For example, if we added a
host named blade123
, we can run:
unix$ lx start blade123
15. Reporting Issues
To report an issue, use lx report
to gather system information.
This program collects information from the system and
builds an archive to be sent to support.
unix$ lx report report: lxreport.231009... version... procs... logs... stacks... stack lxmeta100... stack kvds103... stack kvms100... stack spread... stack kvds102... stack kvds100... stack kvds101... stack lxqe100... # send this file to support. -rw-rw-r-- 1 leandata leandata 54861 Oct 9 14:58 lxreport.231009.tgz
As printed by the command output, the resulting tar file should be sent to support.
The archive includes:
-
installed version numbers
-
underlying OS names are versions
-
complete disk usage for the installed systems
-
complete process list for the installed systems
-
memory usage for the installed systems
-
lx process list
-
logs for components (last log file only, for each one)
-
stacks for each component
-
stacks for each core file found
When kvms
is still running, the archive includes also:
-
statistics for the sytem
-
long list of kv resources
-
process list for each kvds
-
file list for each kvds