Compatibility of third party application plugins, extensions or themes cannot be guaranteed. Many times, these plugins are of questionable quality, dubious origin, out of date, and poorly documented; so there is no way for our team to ensure compatibility of a plugin with your JumpBox based application.

While it may be possible for you to add a plugin to a registered JumpBox, doing so may prevent the application from correctly functioning, break the JumpBox Administration portal or render your JumpBox completely useless. Depending on your support agreement, if you have one, JumpBox Support Engineers may not be able to help you. So please, proceed down this path with extreme caution.

Locally from the JumpBox

You can access MySQL locally by registering, then SSHing into your JumpBox as the admin user and running the command:

sudo mysql --defaults-file=/etc/mysql/debian.cnf 

This will connect you as the 'debian-sys-maint' user, which is ALMOST as good as root. If you truly need to connect as the root MySQL user, get the root password out of the debian defaults file:

sudo grep password /etc/mysql/debian.cnf

and use that password when connecting as follows:

 mysql -u root -p

Over the Network

For security reasons, the MySQL server installed on the JumpBox is not accessible from remote machines. These instructions show you how to change this yourself. Please understand that this may be a bad idea if your JumpBox is not on a secure network, so proceed with caution.

Register then SSH into your JumpBox and run the following command to edit the MySQL configuration file:

sudo nano /etc/mysql/my.cnf

Find the "bind-address" line and replace 127.0.0.1 with 0.0.0.0

#bind-address           = 127.0.0.1
bind-address            = 0.0.0.0

Now restart MySQL and it should be accessible remotely, but before that is useful, we need to grant access to modify a database to a remote user

GRANT ALL PRIVILEGES ON mantis.* TO 'root'@'%' IDENTIFIED BY 'secret';

This will enable a user called 'root' on any remote host (that is what the @'%' means) who uses the password 'secret' to do anything (except GRANT privileges) to any table on the mantis database. For details see the MySQL 5.0 documentation on the GRANT command.

Now you can access MySQL remotely, either using a GUI admin tool or a command line too like mysql:

mysql -h JumpBoxIP -u root -p

Time synchronization in virtual environments is a somewhat complex subject. Trying to support it across various virtual environments further complicates matters. The following is a summary of the situation as it affects JumpBox users.

VMWare Users

For users of a VMWare product the first thing to do is ensure that the tools.syncTime parameter is set to TRUE in your JumpBox.vmx file. If it is set to FALSE, then shutdown your JumpBox and change the setting to TRUE then start the JumpBox. The JumpBox time should now be kept in sync with the host system. tools.syncTime = TRUE is the intended default setting, some past JumpBox release did not have this set.

Other Virtualization Users

There are other options for non VMWare users. One can install the NTP daemon which will automatically and continuously try to sync the JumpBox time with remote network machines. This has disadvantages and limitations in virtual environments. A similar option would be to periodically run the ntpdate command which synchronizes the JumpBox time with a remote system. This may be slightly better than running the actual ntp daemon.

Why is this so hard?

The standard way that time sync should work in virtual environments is that the guest OS (the JumpBox in this case) should be synced with the host OS. This, however, requires that the virtualization platform specific guest tools be installed. At this point, this is not possible on all platforms due either to licensing or technical limitations in the guest tools provided by various virtualization platform vendors. We expect this situation to improve over time.

Every JumpBox is configured to deliver email just like any other mail server on the internet. Users may run into trouble when using a JumpBox on a local network that is connected to the internet through a cable modem or DSL connection. Some mail servers (like Gmail) may not accept email from hosts using these types of connections. In these cases, your ISP may provide an SMTP relay server that you can configure your JumpBox to use.

To configure your JumpBox to send mail through an SMTP relay server you will have to register your JumpBox and enable shell access then SSH to your JumpBox as the 'admin' user and do the following:

# edit the postfix config file as root
sudo vi /etc/postfix/main.cf
# change the line that says "relayhost = " to say
# "relayhost = smtp.yourcompany.com "
# save the changes then reload the postfix config
sudo postfix reload

This takes care of most user's mail delivery problems but you may still have some recipients where this is not sufficient. Unfortunately, these cases are harder to diagnose and vary widely from recipient to recipient.

Other environmental issues that are external to the JumpBox may make receiving email difficult, these include:

• DNS entry incorrect or unavailable
• Reverse DNS entry incorrect or unvailable

Testing Mail

To test whether email is getting delivered (either before or after performing the above steps) you can do the following on the command line of the JumpBox:

echo foo | mail -s test user@domain.com

Check your spam folder to see if it was marked as spam. You can also check the mail.log file and see if the mail was accepted by the remote host, sometimes you will be told in this logfile why a message was rejected:

less /var/log/mail.log

Additional Notes

Note: The SMTP Server setting will be configurable through the JumpBox Admin interface in our upcoming JumpBox platform update.
Note: JumpBoxes are not configured to receive email from the internet.
Note: Some applications have Application level SMTP server settings, you may use these if you prefer, but the above method should work across all JumpBoxes.

JumpBoxes don't have default passwords, you choose the password when you first boot and configure the JumpBox. That password is used to set the password for the JumpBox management console and for the default administrative user for the application.

The primary goal of a JumpBox is to provide users the most reliable, most convenient and fastest way to get a fresh start using the bundled application. Importing you old application data into a JumpBox is not one of our primary design goals. It may be possible to import your old application data but it may not be easy.

As of the writing of this FAQ entry none of the JumpBox support offerings include assistance with importing old application data. You are welcome to try and import your old data yourself but we cannot guarantee success or provide support. Feel free to ask questions in the JumpBox forums, since others may have solved the problem already.

If you succeed in importing your old application data, we cannot guarantee that the rest of the JumpBox functionality will work as intended (backup/restore, etc) since this functionality has only been tested with our known application state.

Austin

All JumpBoxes have been stripped of unnecessary packages to minimize download size. This includes everything required to compile or build additional software. No need to worry though, on a registered JumpBox, getting all the build tools you need is simple. Just make sure you have enabled shell access and SSH into the JumpBox and run:

sudo apt-get update
sudo apt-get install build-essential

Whatever you are trying to build may have additional dependencies but build-essential should get you started.

Remember to tread with caution on the command line. You could render your JumpBox useless and we don't support any packages that don't ship on the JumpBox.

PHPMyAdmin is a Web based MySQL Administration tool. You might find it handy on a JumpBox that uses MySQL (Drupal, Joomla, MediaWiki, PunBB, vTiger, SugarCRM, and WordPress). It doesn't come installed on a JumpBox by default, but installing it is not too complicated. Just Enable shell access, SSH to your JumpBox as admin and follow these instructions:

sudo apt-get update
sudo apt-get install phpmyadmin
sudo rm /var/www/phpmyadmin
sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf.d/
sudo nano /etc/phpmyadmin/apache.conf

At this point, you are editing the PHPMyAdmin apache configuration file. All you need to do is add a line a the top that says*

Alias /phpmyadmin /usr/share/phpmyadmin

Now you can save the changes you have made and then restart apache and get the MySQL root password as follows:

sudo /etc/init.d/apache2 restart
sudo grep password /etc/mysql/debian.cnf

Now to access PHPMyAdmin on your JumpBox just point your browser to http://jumpboxip/pypmyadmin. You will use the username root, and the password your found above.

NOTE: 'sudo' is a command that lets the admin user do things as the privileged root user. The first time you run it, it will ask you for the admin user's password. The admin user can do anything on the JumpBox using this command.

* If your JumpBox is accessible on the internet, you may want to change '/phpmyadmin' to some other unique string that you can remember, like '/myadmin1' and access it via that URL. Misconfigured PHPMyAdmin installations are popular hacker targets.

Details about the login for a specific JumpBox application can be found in the README.txt file that came with the JumpBox. Typically the username will be admin and the password is the one you provided during the initial setup process.

When the JumpBox is finished booting you will see the IP address displayed in the console for the virtualization software.

Also as part of configuring the JumpBox you will provide a hostname for the application. That hostname can then be used to access the application.

• Windows: http://your-hostname
• Mac OS X: http://your-hostname.local
• Linux: You should use the IP address unless you have a Zeroconf resolver library installed. Then you can use http://your-hostname.local

Replace your-hostname with the hostname you set when configuring the appliance.