You will need:

• WSL2 setup with Firefox installed (mine uses Ubuntu 20.04)
• VcXsrv
• geckodriver

How it works

VcXsrv starts up an X server on the Windows host machine, and what WSL will do is connect to this server to pass on the details of what programs need to be displayed (in this case, the browser window). Geckodriver is there purely as a middle layer for Selenium to be able to interact with Firefox.

VcXsrv setup

This setups the X server so that Windows can display graphical data coming from the Ubuntu instance.

1. Download and install
2. Start it up with the the command line parameter “-ac”. This flag removes access control restrictions for connecting clients (which is okay as long as this server isn’t exposed on the open Internet and that the only client connecting is the Ubuntu instance)
3. Allow connections to VcXsrv on Windows Firewall

The “-ac” flag and allowing the program through Windows Firewall is pretty important. When I didn’t do this, Ubuntu would give me cryptic error messages like “Broadway display type not supported”, but once I set up these access controls, everything was fine.

Bash setup

Install firefox

sudo apt install firefox

Export DISPLAY variable in .bashrc (or for whatever terminal you use, maybe .zshrc, etc.)

export DISPLAY=$(ip route | awk '{print $3; exit}'):0

This will configure your DISPLAY variable to use the IP address listed in the resolv.conf file. The IP address listed there is the IP address of the X server that will be used for displaying the browser window.

Start up VcXsrv as described in the above and then try to open Firefox. The Firefox window should open.

Geckodriver setup

This acts purely as the API interface that allows Selenium to interact with Firefox. Selenium looks for this executable when controlling the web browser.

1. Download geckodriver (make sure to get the Linux one and not the Windows one)
2. Put it in /usr/bin (or alternatively some other folder in your PATH)

Selenium sample on Python

I tend to use Python when running Selenium code, and I haven’t tried it on another language (I imagine the principles are similar). Here is a piece of sample code for starting up the browser and opening up a website, but really any Selenium code can be used.

import time

from selenium import webdriver
from selenium.webdriver import DesiredCapabilities

def execute_with_retry(method, max_attempts):
    e = None
    for i in range(0, max_attempts):
        try:
            return method()
        except Exception as e:
            print(e)
            time.sleep(1)
    if e is not None:
        raise e

capabilities = DesiredCapabilities.FIREFOX
capabilities["marionette"] = True
firefox_bin = "/usr/bin/firefox"
browser = execute_with_retry(lambda: webdriver.Firefox(
    firefox_binary=firefox_bin, capabilities=capabilities), 10)

browser.get("https://www.google.com")

time.sleep(10)

browser.close()

This post is about deploying an instance of Seafile using Docker on a non-standard port (i.e. not 80 and 443). The reason to deploy the app on a non-standard port is usually because there is already another webserver running on that port (in my case Apache 2). In such scenarios, it is necessary to set up a reverse proxy so the Seafile port can be exposed by Apache on ports 80/443. Under typical circumstances, deploying Seafile on a standard port would mean that the app would host itself without the need for Apache 2 at all. This post also assumes Ubuntu 16.04 as the operating system, but in theory should apply to other Linux OS’s.

The process can be split into multiple parts:

1. Setup Docker
2. Deploy Seafile
3. Configure Apache 2
4. Setup systemd
5. Setup e-mail (optional)
6. Backing up the image
7. Troubleshooting

Setup Docker

This guide won’t go into depth on how to setup Docker, but rather the setup guide and more information about what Docker is can be found here: https://docs.docker.com/get-started/

Deploy Seafile

The key page in the Seafile documentation for deploying Seafile within Docker can be found here: https://github.com/haiwen/seafile-docker. The command I used is as follows:

docker run -d --name seafile \
  -e SEAFILE_SERVER_HOSTNAME=seafile.example.com \
  -e SEAFILE_ADMIN_EMAIL=me@example.com \
  -e SEAFILE_ADMIN_PASSWORD=a_very_secret_password \
  -v /opt/seafile-data:/shared \
  -p 8000:80 \
  seafileltd/seafile:latest

I recommend setting up Seafile with an actual secret password because it’s not easy to change once it’s set up.

Note that the port argument shows 8000:80. It means that Docker will use the host port 8000 and the container will use port 80 – meaning that using Docker will interpret requests from my host OS on port 8000 as requests on port 80 in the container. 8000 was used on my setup because port 80 was already used.

Once the command is executed, the necessary files will be downloaded and the container will start and will be accessible on port 8000.

There is also an option to setup Seafile with an SSL cert from Let’s Encrypt, but I didn’t do this because I already had a cert that I wanted to reuse.

Once the server is up, navigate to https://seafile.example.com/sys/settings/ and change SERVICE_URL and FILE_SERVER_URL to match your domain name.

Configure Apache 2

Adding a reverse proxy on Apache 2 will allow Apache 2 to route requests to port 8000, which will go to port 80 in the container. The main reference for this section is this: https://manual.seafile.com/deploy/deploy_with_apache/. This is done by adding a new site to Apache 2. The following configuration assumes that a LetsEncrypt SSL certificate is used.

cd /etc/apache2/sites-available
sudo nano seafile.conf

<IfModule mod_ssl.c>
<VirtualHost *:443>
    ServerName seafile.example.com
    ServerAdmin me@example.com

    RewriteEngine On

    # ModSecurity does not process requests.  There is a hard limit of 1 GB
    # with ModSecurity.
    SecRuleEngine Off

    # Whitelist internal IPs for mod_evasive
    DOSWhitelist 192.168.1.*

    <Location /media>
        Require all granted
    </Location>

    # Stuff for seafile server
    ProxyPass /seafhttp http://127.0.0.1:8082
    ProxyPassReverse /seafhttp http://127.0.0.1:8082
    RewriteRule ^/seafhttp - [QSA,L]

    # Stuff for seahub
    SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:8000/
    ProxyPassReverse / http://127.0.0.1:8000/

    ErrorLog ${APACHE_LOG_DIR}/seafile_error.log
    CustomLog ${APACHE_LOG_DIR}/seafile_access.log combined

    Include /etc/letsencrypt/options-ssl-apache.conf

    SSLCertificateFile /path/to/cert/file.pem
    SSLCertificateKeyFile /path/to/cert/key/file.pem
</VirtualHost>
</IfModule>

I’ve added my local domain to the whitelist so that mod_evasive doesn’t think my local host is a threat.

There are two sets of ProxyPass and ProxyPassReverse lines. The reason for this is that Seafile is split up into Seahub and Seafile, where one uses port 8082 (by default), while the other uses 8000. These two lines are essentially what allows Apache to read requests from port 443 and pass them on to the container.

Once the file is saved, execute the following

sudo a2ensite seafile.conf
sudo service apache2 reload

Navigating to the site at the Apache 2 defined port should now load Seafile without having to go to port 8000.

Setup systemd

systemd allows the Docker container to be started up on boot, and be controlled like this:

sudo service seafile start/stop/restart

The configuration is as follows:

sudo nano /etc/systemd/system/seafile.service

[Unit]
Description=Seafile Server
After=network.target mysql.service

[Service]
Type=oneshot
ExecStart=/usr/bin/docker container start seafile
ExecStop=/usr/bin/docker container stop seafile
ExecReload=/usr/bin/docker container restart seafile
RemainAfterExit=yes
User=root
Group=root

[Install]
WantedBy=multi-user.target

Once the configuration is saved, shut off the existing running instance of Seafile and then let systemd start it up for you.

sudo systemctl daemon-reload
sudo service seafile start

At this point, Seafile should start automatically on boot, with Apache 2 doing a reverse proxy to the true Seafile port.

Setup e-mail (optional)

Optionally, Seafile can be configured to send e-mails. The reference is here: https://manual.seafile.com/config/sending_email/. The config file should be under:

/opt/seafile-data/seafile/conf/seahub_settings.py

I happen to be using Gmail SMTP, so at the end of the file I’ve added

EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_HOST_USER = 'me@example.com'
EMAIL_HOST_PASSWORD = 'password'
EMAIL_PORT = 587
DEFAULT_FROM_EMAIL = EMAIL_HOST_USER
SERVER_EMAIL = EMAIL_HOST_USER

Backing up the image

After setting everything up, you’ll probably want to backup the Docker image. First, print out the list of running containers

sudo docker ps

Then take a snapshot of the current running state:

docker commit -p <container ID> <whatever you want to call this snapshot>

Running this command lists all the images and should show this newly saved image:

sudo docker images

I don’t have a private docker repository, so I saved the image to the disk and backed up the file by doing the below. Just make sure to actually move the image to an actual backup location.

sudo docker save -o <whatever path you want>/<filename>.tar <the name used earlier>

The image should be backed up now. To restore the image, it’s a matter of running this:

sudo docker load -i <path to the backup file>

Listing the images as above should show that the image was successfully loaded. Running this starts it back up again.

sudo docker run <container name>

Troubleshooting

Seafile logs can be helpful if it doesn’t start up correctly. These can be found at:

/opt/seafile-data/logs/seafile

There may be a need to ssh into the Docker container. The command for that is:

sudo docker exec -it seafile /bin/bash

Bash for Windows has been working pretty great for me until I needed to run Selenium Webdriver on it. I quickly learned that it wouldn’t work just work right out of the box, and the set up for it is quite convoluted.

You will need

• Bash for Windows
• Xming – This will actually allow the Window to appear on the screen
• geckodriver – Selenium now needs this to run Firefox

Bash setup

Install Firefox:

sudo apt-get install firefox

Export DISPLAY variable in ~/.bashrc. Just add this to the ~/.bashrc:

export DISPLAY=:0

Xming setup

Just download it from the link above and run it.

Download geckodriver

Download geckodriver from the link above and put in the /usr/bin/ folder in Bash for Windows.

Running Selenium

Here is a piece of sample Python code I used to setup the web browser. It will setup the browser, open Google, sit there for 10 seconds and then quit.  Make sure to have Xming running otherwise the browser isn’t going to start.

import time

from selenium import webdriver
from selenium.webdriver import DesiredCapabilities

def execute_with_retry(method, max_attempts):
    e = None
    for i in range(0, max_attempts):
        try:
            return method()
        except Exception as e:
            print(e)
            time.sleep(1)
    if e is not None:
        raise e

capabilities = DesiredCapabilities.FIREFOX
capabilities["marionette"] = True
firefox_bin = "/usr/bin/firefox"
browser = execute_with_retry(lambda: webdriver.Firefox(
    firefox_binary=firefox_bin, capabilities=capabilities), 10)

browser.get("https://www.google.com")

time.sleep(10)

browser.close()

The best food we ate in Osaka was definitely Yakiniku at a place called Sora (空), which means “sky”. Pieces of pre-marinated meats are cooked on the grill, and everything was delicious.

Even though we were not in Hiroshima, we got to eat Okonomiyaki again. This time, there was a grill at our table and a server at the restaurant cooked it for us while we watched.

Osaka is also famous for deep fried skewers using different foods like chicken, squid, and veggies. The skewers are served with a special sauce and according to the local culture, double-dipping is highly frowned upon. We at this at a famous Japanese skewer restaurant called Daruma (だるま) with some friends in Osaka. My personal favourite was the kind with intestines.

Osaka Castle is another well known landmark in the city. Since the many wars that the castle has been involved in since its construction in the 16th century, the castle has now been restored and the inside has been converted into a museum with a rooftop observation deck.

We also visited the Osaka Science Museum. It was full of interactive exhibits that taught various concepts in the natural sciences, like magnetism, sound, air drag, and chemical reactions. The best exhibit was definitely the one on nuclear fission.

Takoyaki, another one of Osaka’s local delicacies, was also something we had to try. The ball is made of a batter and inside it, there are bits of octopus meat, and the entire thing is cooked in a special Takoyaki grill. After it is cooked, Takoyaki sauce and mayonnaise is added. It is interesting to eat since the outer shell is quite soft, but the octopus is not. The sauce also adds some sweetness to the flavour.

While I was no stranger to Takoyaki since I have had it previously, we got to try a kind that used egg for the outer shell rather than the batter. It was definitely new and special, but I have to say the regular kind was way better.

We also stumbled onto a restaurant called the “International Beer Museum” that had different beers from around the world on tap. It had been a long time since I had a Helles, so that’s what I got. I also realized that I haven’t been posting much about Japanese beer and the reason is that it is quite easy to get the same name brands in Vancouver (with the exception of Suntory Premium Malt’s) and they taste the same too!

I also didn’t think I’d be able to eat Currywurst in Japan either. Needed way more sauce though, but I understand that kind of sauce is probably hard to come by in Japan.

And I also didn’t think I’d see an Asian person wearing Lederhosen either.

Links to photo albums:

• Osaka
• Osaka Science Museum

The best sushi I’ve ever had was at the Tsukiji Fish Market. The place was called Daiwa (大和) and there is always a line up to get in. In Canada, we are used to eating a lot of raw salmon, but in Japan, it is all about tuna – especially bluefin tuna. We were also served sea urchin too and I would say that was the only time I’ve ever had sea urchin that was delicious. (More info here)

Sashimi by itself is definitely very delicious too. This sashimi platter was from a restaurant called Uokin (魚金), near Shinbashi Station in Tokyo.

At the same restaurant, we also ate cooked fish head. I’m sure it doesn’t look that appetizing to a lot of people, but it definitely tasted very good, and I’m someone who does not normally eat fish head, but I tried it since our hosts had ordered it. Good thing I tried it too!

This is probably a lesser known dish in Japan, but we were served assorted shellfish that were still alive along with a grill to cook them in. I thought that was pretty special. That was from a seafood restaurant chain called 鈴木水産.

And of course, there is ramen, a classic Japanese noodle soup dish. My favourite was from a place called Ramen Shokudo Ikinaisshou in Akihabara. Some people even like to mix the soup with rice too, and that’s really good too.

Lastly, here is a type of Japanese food known as a teishoku, or a “meal set”. This one, from a chain called Yayoiken (やよい軒), has a bowl of rice, soup, and various side dishes in a tray. This is more of a fast food place though.

Link to photos from Tokyo: here

Link to photos of just food: here