Using the JFileServer Docker Images

There are a number of Docker images available with various configurations of JFileServer. The following Docker images are available :-

Image	Description
filesysorg/jfileserver	JFileServer file server configured with the SMB server enabled
filesysorg/jfileserver-db-postgres	JFileServer file server plus the PostGres database filesystem add-on
filesysorg/jfileserver-enterprise	JFileServer file server plus the Enterprise add-on, to add support for SMB2 and SMB3

For details of how to use the JFileServer Enterprise Docker images see here.

Using the filesysorg/jfileserver Docker Image

The filesysorg/jfileserver Docker image contains a core JFileServer setup. The default setup enables the SMB server with support for SMB1.

To run the default JFileServer setup use the following command :-

docker run -d --rm --name jfileserver -p 445:445 filesysorg/jfileserver

The Docker image will be downloaded from the Docker hub if you have not already downloaded it. This will start a JFileServer running the SMB server on the native SMB port 445. On linux, macOS and other Unix systems you should be able to connect to the SMB file server by using the host name or IP address in the UNC path when mapping the shared drive path. For example, if the host IP address is 192.168.1.2 you would use a UNC path of \\192.168.1.2\jfileshare to map to the default shared path of the file server. There are two users configured for the file server, an administrator user with the username admin password jfilesrv, and a normal user with username user password java. You will need to use either the admin or normal username and password when connecting to the file server.

To stop JFileServer use the command :-

docker stop jfileserver

Using Volume Mapping To Override The Configuration

The JFileServer Docker image has the following files and folder layout :-

/jfileserver
 |
 +- /jfileShare
     |
     +- sharedFile.txt
 +- /lib
     |
     +- bcprov-jdk5on-1.48.jar
     +- hazelcast-3.10.1.jar
     +- jfileserver-1.1.0.jar
     +- jna-5.1.0.jar
     +- jna-platform-5.1.0.jar
 +- /logs
     |
     +- jfileserver.log
 +- fileSrvConfig.xml
 +- runsrv.sh

We can use Docker volume mapping to override the default paths and map them to paths on the host system. To override the default shared folder to a folder on the host system we could use the command :-

docker run -d --rm --name jfileserver -p 445:445 -v <path-to-host-folder>:/jfileserver/jfileShare filesysorg/jfileserver

To have the JFileServer log written to a file on the host we can use the command :-

docker run -d --rm --name jfileserver -p 445:445 -v <path-to-host-folder>:/jfileserver/logs filesysorg/jfileserver

To override the default JFileServer configuration we can map the /jfileserver/fileSrvConfig.xml to a configuration file on the host system :-

docker run -d --rm --name jfileserver -p 445:445 -v <path-to-host-config-file>:/jfileserver/fileSrvConfig.xml filesysorg/jfileserver

You can use multiple volume maps on the command line, so the above examples could be combined into the command :-

docker run -d --rm --name jfileserver -p 445:445 -v <path-to-host-folder>:/jfileserver/jfileShare -v <path-to-host-folder>:/jfileserver/logs
 -v <path-to-host-config-file>:/jfileserver/fileSrvConfig.xml filesysorg/jfileserver

Note: On Windows the default Docker setup only allows host paths within the \Users folder so to redirect the logs folder to a host path you would use -v "/c/Users/<username>/logs:/jfileserver/logs". The log file jfileserver.log should appear within the hosts logs\ folder as the JFileServer starts up.

Another way to extend the JFileServer image would be to use a Docker file that extends the JFileServer image by copying a new configuration file over the original file. This is how the PostGres database filesystem and Enterprise add-on Docker images are layered on top of the core JFileServer Docker image.

Using Environment Variables To Override The Configuration

The default configuration can be overridden using environment variables. Also the shared folder and the logs folder can be redirected to use host folders via volume mapping.

As JFileServer is running in a Docker container it can use the default privileged ports for the various file servers. The SMB server will use TCP ports 139 and 445, and UDP ports 137 and 138, by default. The FTP server will use port 21 by default.

The following environment variables are used :-

Variable Name	Description	Default Value
JFSRV_SMB_ENABLE	Enable the SMB server	true
JFSRV_FTP_ENABLE	Enable the FTP server	false
JFSRV_NFS_ENABLE	Enable the NFS server	false
JFSRV_SMB_SERVERNAME	Name of the SMB server, for NetBIOS connections	jfilesrv
JFSRV_SMB_DOMAIN	Domain or workgroup that the SMB server belongs to	domain
JFSRV_SMB_DIALECTS	SMB dialects that the SMB server will negotiate	SMB1
JFSRV_SMB_DEBUGFLAGS	SMB debug flags	Negotiate,Socket,State
JFSRV_FTP_PORT	Port that the FTP server listens on	21
JFSRV_FTP_DEBUGFLAGS	FTP debug flags	File,Search,Error,DataPort,Directory
JFSRV_NFS_DEBUGFLAGS	NFS debug flags	File,FileIO
JFSRV_SHARE_NAME	Shared filesystem name	jfileshare
JFSRV_SHARE_COMMENT	Comment for the shared filesystem	Test shared filesystem
JFSRV_ADMIN_USER	Administrator user name	admin
JFSRV_ADMIN_PASSWORD	Administrator user password	jfilesrv
JFSRV_NORMAL_USER	Normal user name	user
JFSRV_NORMAL_PASSWORD	Normal user password	java
JFSRV_DEBUG_OUTPUT	Debug output destination, 'File' or 'Console'	File
JFSRV_DEBUG_LOGPATH	Log file path when using 'File' debug output	/jfileserver/logs/jfileserver.log

We can specify overrides for the environment variables on the Docker command line, for example, to enable the FTP server we would use :-

docker run -d --rm --name jfileserver -e JFSRV_FTP_ENABLE=true -p 445:445 -p 21:21 filesysorg/jfileserver

If you are having problems with JFileServer you can redirect the log output to the console and run the Docker image interactively using :-

docker run --rm --name jfileserver -e JFSRV_DEBUG_OUTPUT=Console -p 445:445 filesysorg/jfileserver

You should then see the debug log output to the console, and JFileServer waiting for a client to connect or any errors from the file server startup :-

JFileServer starting, enter 'x' to shutdown server, 'r' to restart server ...
Starting server NetBIOS ...
Starting server SMB ...
[SMB] SMB Server JFILESRV starting
[SMB] Version 1.0.0, Java VM 25.181-b13, OS Linux, version 4.9.125-linuxkit
[SMB] Using authenticator org.filesys.server.auth.EnterpriseSMBAuthenticator, mode=USER
[SMB] Server timezone offset = 0hrs
[SMB] Dialects enabled = [Core,CorePlus,DOS LANMAN 1.0,LANMAN1.0,DOS LANMAN 2.1,LM1.2X002,LANMAN2.1,NT LM 0.12]
[SMB] Shares:
[SMB]  [jfileshare,DISK,,[/jfileserver/fileShare]] [/jfileserver/fileShare]
[SMB] Added NTServer flag to host announcement
[SMB] Binding TCP-SMB session handler to address : ALL
[SMB] Binding NetBIOS session handler to address : ALL
[SMB] Request handler SMBRequestHandler_1 waiting for session ...
[SMB] Listening for connections on [SMB,TCP-SMB,ALL:445]
[SMB] Listening for connections on [SMB,NetBIOS,ALL:139]
[SMB] Waiting for new connection ...

To stop JFileServer when running in interactive mode use <Ctrl-C>, the file server should shutdown cleanly, this may take from a few seconds to a minute or so.

Using the filesysorg/jfileserver-db-postgres Image

The filesysorg/jfileserver-db-postgres image extends the core JFileServer image by adding the PostGreSQL database filesystem driver. Instead of the shared filesystem being mapped to a folder in the container image, or the host filesystem, the shared filesystem is held within a set of PostGres database tables.

The filesysorg/jfileserver-db-postgres Docker image does not contain the PostGres database server. A Docker compose file is used to run the PostGres database server and JFileServer file server images as two seperate containers that work together. Here is a sample docker-compose.yml that can be used to run the JFileServer and PostGres servers :-

version: "3"

services:
  postgres:
    image: postgres
    restart: always
    env_file:
      - 'jfileserver-postgres.env'
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

  file_server:
    image: filesysorg/jfileserver-db-postgres
    links:
      - postgres
    env_file:
      - 'jfileserver-postgres.env'
    environment:
      JFSRV_DEBUG_OUTPUT: console
    ports:
      - "445:445"

volumes:
  pgdata:

The Docker compose file is configured to use a Docker volume to store the PostGres database server data outside of the Docker container. See the section below (Preserving The PostGreSQL Data) for different options available to store the database server data on the host.

The above Docker compose file uses a seperate file to specify the environment variables that are used by the PostGres and JFileServer servers, here is a sample environment variable file :-

POSTGRES_USER=jfileserver
POSTGRES_PASSWORD=fileserver
POSTGRES_DB=jfileserver

As well as the environment variables defined for the JFileServer core Docker image the following environment variables are also used :-

Variable Name	Description	Default Value
JFSRV_DB_DSN	The PostGres JDBC driver data source name for the JFileServer database tables	jdbc:postgresql://postgres/jfileserver
JFSRV_DB_USER	Database user name for the PostGres connection	jfileserver
JFSRV_DB_PASSWORD	Database password for the PostGres connection	fileserver

By using the jfileserver-postgres.env file the same values will be passed to the Postgres database server and JFileServer file server.

Preserving The PostGreSQL Data

In order to preserve the PostGres database server we need to use a Docker volume or a folder on the host system, to store the database data outside of the Docker container. There are two ways we can specify the Docker volume :-

• Create a Docker volume

To create a Docker volume with the name pgdata use the command :-

docker volume create pgdata

Then in the docker-compose.yml file use a volume mapping in the volumes: section, to the services: postgres: section, to map the PostGres database server data into the external volume, and add the volumes:' section to the end of the docker-compose.yml file :-

services:
  postgres:
    ...
    volumes:
      - pgdata:/var/lib/postgresql/data
...
volumes:
  pgdata:

• Use a local folder on the host

Create a folder on the host system to hold the PostGres database server data files, then in the docker-compose.yml file use a volume mapping in the volumes: section to map the PostGres database server data folder to the host folder, for example :-

volumes:
  - ~/JFileServer/pgdata:/var/lib/postgresql/data

Using the JFileServer SMB Server On Windows

To use the JFileServer Docker image to run an SMB server on Windows requires some additional work to access the SMB server. A Windows host uses the native SMB port 445 to run a local file server as well as to access various services such as remote registry editing, access to the event log manager and service manager and many other functions. When running the JFileServer Docker image on Windows we cannot map the native SMB port 445 from the Docker container to the host system as the port will already be in use. Instead we need to setup a network route to the Docker VM that is running the JFileServer image.

To setup a network route to the JFileServer Docker container :-

• Get the Docker VM IP address using :-

docker-machine ip default

• Start the JFileServer container without a port mapping using :-

docker run --name jfileserver filesysorg/<jfileserver-image-name>

• Get the IP address of the JFileServer container using :-

docker inspect jfileserver | findstr IPAddress

• Add network routing to the JFileServer container :-

route add /P <container-network-IP> MASK 255.0.0.0 <docker-machine-IP>

For example if the container IP address is 172.17.0.2 and the Docker machine IP is 192.168.99.100 the routing command would be

route add /P 172.0.0.0 MASK 255.0.0.0 192.168.99.100

• Map a network drive from the Windows host using a UNC path of \\<docker-machine-IP>\jfileshare using the admin or normal user name and password configured.