Floating Controller
Getting Started#
JEB Pro Floating licenses provide more flexibility than individual JEB Pro licenses, and can be distributed to many users within an organization. A floating build licensed for N seats will allow any N clients to connect to it concurrently. When a client leaves, its seat is vacated, allowing another JEB client to start by connecting to the Controller.
JEB Clients regularly probe the Controller to determine whether or not they are allowed to run. The check is based on the number of seats available in your licensed build: for example, a floating license for 5 seats allows 5 different users to run JEB concurrently.
In order to start the Controller, use the --controller
flag along with the -c
flag:
$ jeb_wincon.bat -c --controller
$ jeb_linux.sh -c --controller
$ jeb_macos.sh -c --controller
Additional Controller-specific command-line flags (--interface
, --port
, --protocol
) are detailed below.
After starting the Controller, follow the prompt: You will be asked to input your password, accept the license agreement, and generate a license key.
Sample log output:
C:\jeb>jeb_wincon.bat -c --controller
JEB decryption password: ***************
...
<EULA>
...
Write "yes" to agree, then press enter: yes
Hello Nicolas Falliere. Set up your JEB controller by generating a license key. This one-time operation will only take a few seconds.
Please visit https://www.pnfsoftware.com/genlk, and use the following "license data" blob to generate a key
License data: .............................................
Input your license key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Mode: Controller for floating clients
Note: X client(s) may simultaneously connect to this controller instance
Listening on 0.0.0.0/0.0.0.0:23477...
If you need to customize the Controller's address or protocol, you may now stop it with the Ctrl+C keyboard command.
Controller Settings#
After the first step is completed successfully, executing the controller should display something like the following:
C:\jeb>jeb_wincon.bat -c --controller
Mode: Controller for floating clients
Note: X client(s) may simultaneously connect to this controller instance
Listening on 0.0.0.0/0.0.0.0:23477...
As can be seen, by default, the controller is listening on port 23477 on all interfaces, and uses the HTTP protocol. This can be changed by editing the configuration file bin/jeb-client.cfg
and adding entries:
.ControllerInterface = ...
(default: 23477).ControllerPort = ...
(default: all interfaces).ControllerProtocol = ...
(default: 0 (HTTP))
Protocols currently supported are HTTP (0, the default) and HTTPS (1).
Examples#
- Example: the Controller listens on all interfaces, port 30000, default protocol (HTTP):
.ControllerPort = 30000
- Example: the Controller listens on all interfaces, default port (23477), uses HTTPS (protocol 1):
.ControllerProtocol = 1
- Example: the Controller listens exclusively on localhost, port 30000, uses the default protocol HTTP:
.ControllerInterface = localhost
.ControllerPort = 35000
- Example: the Controller listens on all interfaces, port 35000, explicitly uses HTTP (protocol 0):
.ControllerPort = 35000
.ControllerProtocol = 0
- Example: the Controller listens on 10.0.0.25, port 8443, and uses HTTPS instead of HTTP:
.ControllerInterface = 10.0.0.25
.ControllerPort = 8443
.ControllerProtocol = 1
Client Settings#
Start your desktop client using one of the standard start-up scripts. For example, on a Windows machine:
$ jeb_wincon.bat
$ jeb_linux.sh
$ jeb_macos.sh
Your JEB client settings should mirror your Controller settings: specify the controller hostname/interface, port, and protocol, in your client's jeb-client.cfg.
The first time you start your JEB UI client, a dialog box will request you to specify your Controller's location. You will also have the opportunity to configure your proxy settings, if you are using one.
You may also configure your client's settings by directly editing jeb-client.cfg
.
Examples#
- Example: the Controller to connect to is at 192.168.23.45, default port (23477), default protocol (HTTP):
.ControllerInterface = 192.168.23.45
- Example: the Controller to connect to is at some-network.com, port 30000, protocol HTTP (explicitly specified):
.ControllerInterface = some-network.com
.ControllerPort = 35000
.ControllerProtocol = 0
- Example: the Controller to connect to is at 10.0.0.25, port 8443, protocol HTTPS:
.ControllerInterface = 10.0.0.25
.ControllerPort = 8443
.ControllerProtocol = 1
Technical Notes#
- JEB Clients as well as JEB Controller are the same binary file: there is no separate package for the Controller.
- The
--controller
flag and other floating-specific flags are only available for Floating builds. - The Controller should be started before Clients.
- Clients regularly 'ping' the Controller. Therefore, the Controller should always be reachable by running instances of JEB client. To minimize potential problems due to network latency, it is recommended to run JEB and the Controller within the same local network (if possible).
- By default, the Controller listens on all interfaces, on port 23477, and uses the HTTP protocol for communication with its clients. This can be changed by setting the .ControllerInterface, .ControllerPort, .ControllerProtocol values in your configuration file.
- By default, the Controller and clients use HTTP for communication. In order to use HTTPS, make sure to set the .ControllerProtocol value in your configuration file to 1. (HTTPS is only available for JEB 3.0.6 and above.)
- JEB client instance and the Controller may be run in different environments (e.g., a Controller on Linux, Clients on Windows or macOS, etc.)
- The controller property .ControllerMessage is used to provide messages, visible by clients on the Controller portal.
- Your controller portal can be reached by visiting the web page:
ControllerProtocol://ControllerInterface:ControllerPort
, e.g. http://10.0.0.25:23477 or https://192.168.12.23:35000. It displays information about the controller capacity and currently connected clients. - Controller settings can be provided by command-line flags
--interface=
,--port=
,--protocol=
. They take precedence over the settings injeb-client.cfg
. Examples:- Start a controller on Linux, port 36000, listen on interfaces specified in the configuration file (or all if none are specified):
jeb_linux.sh -c --controller --port=36000
- Start a Windows client:
jeb_windows.sh -c --controller --interface=192.168.0.56 --port=36000
- Start a controller on Linux, port 36000, listen on interfaces specified in the configuration file (or all if none are specified):
Updating the Controller#
There is no auto-update feature in the controller. The update procedure is:
- Check your registered email address for a JEB update email ("JEB xxx is available...")
- Download the software archive
- Copy the archive to the root of your JEB folder and rename the file to
update.zip
- Create a text file named
update.pwd
- Store the email-provided password inside this file
- Start your controller as normal (e.g.,
... -c --controller
); the update will be installed automatically
Troubleshooting#
Issues with SSL (Protocol 1) with JEB<=4.2#
If JEB clients cannot connect to a JEB floating controller when using SSL, see a possible reason below:
Warning
This problem only manifests itself 1) with JEB <= 4.2 and 2) for which the controller uses a JDK >= April 2021 and 3) for which the controller is set up to use SSL/HTTPS (the .ControllerProtocol has the value 1) to communicate with floating clients.
On April 20 2021, Oracle shipped JDKs deprecating the TLS v1/v1.1 protocols (e.g. JDK 8u291 onward, JDK 11.0.11 onward, etc.), which JEB floating clients <=4.2 require when connecting to a JEB controller.
With default Java settings, the floating controller will simply reject such clients. You have 3 options:
- The recommended solution is to upgrade JEB to 4.3 or above (updating to the nnewest version is recommended).
- A workaround is to tweak the Java settings on the controller: edit your
java.security
file (located in your JDK folder). You will see that "TLSv1" is located in thejdk.tls.disabledAlgorithms
entry. Remove it from this entry and add it to thejdk.tls.legacyAlgorithms
one. This will allow your JEB controller to accept incoming client requests. - Another workaround is to use a slightly older Java build on the controller, for which TLSv1 is not deprecated.