Skip to content

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 in jeb-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

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 (dated July 13 2020) or above.
  • 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 the jdk.tls.disabledAlgorithms entry. Remove it from this entry and add it to the jdk.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.