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()

The right stuff

There are three markers of endurance fitness: aerobic capacity, anaerobic threshold, and economy

• Aerobic capacity: AKA “VO2max”, is a measure of how much oxygen you are capable of using when riding at a maximal effort for a few minutes
• Anaerobic threshold: the percentage of your aerobic capacity that you are capable of sustaining for a long time, such as 40 to 70 minutes
• Economy: tied to all metrics of performance in that it has to do with how much energy you waste while riding (e.g. physical structure, pedaling style, position on the bike, and bike-handling skills)

Power duration curve and phenotype

This is a huge generalization, but it shows that performance can be predicted from metrics

• Climbers: can maintain high power outputs even over long durations. Best predictor of success is power to weight ratio
• Sprinters: even higher power outputs with short bursts but drops off quickly over long durations
• Time trialists: Best predictor of success is power at anaerobic threshold. Aerodynamic drag is the biggest obstacle since often courses are quite flat
• All-rounders: someone who is pretty good at at least two of the above and they are often contenders when course conditions don’t favour the specialists

Training beliefs

The athlete must have faith that he is going down the right path for training, and follow the path beginning to end

Some people respond quickly, while some slowly. Some people have muscles made for endurance while others made for power, and it’s the rider’s job to adjust his training based on what he’s know about himself.

Training is always a moving target – what worked last season may not produce the same results

Four steps to training with a purpose

There is no one-size fits all way of training

1. Clear goal – well-defined goal drives training outcome. Even workouts need to have a goal. The combination of the workout goals ultimately point to the season’s goal
2. Expert instruction – e.g coach, mentor, training partner, or even yourself (i.e. by reading this book)
3. Specific practice – Everything done should follow the goal and the expert instruction. Training alone is ideal as it allows control over all aspects of workout without accounting for someone else
4. Immediate feedback – Review data as the workout is happening or immediately after. Need to stay mentally engaged with how one feels during workout

Previous: Chapter 1 – Mental performance
Chapter list: Chapter summaries

We flew into Israel from Tel Aviv and boarded a train to Jerusalem. I totally expected the Middle East to be pretty warm in February, but nope, it was snowing tiny little flakes in Jerusalem. If it weren’t for the Europe trip before this, I would have actually not brought any winter clothes, so I definitely lucked out there.

The Way of the Cross

The crucifixion of Jesus Christ is probably what Jerusalem is most well known for. The Way of the Cross (aka Via Dolorosa) in Jerusalem is what is believed to be the actual path that Jesus walked during his crucifixion – regardless of whether you’re religious or not, it’s still pretty cool to see. This was a key event in the establishment of Christianity. The crucifixion of Jesus is considered to be historically true even by non-religious scholars.

The Way of the Cross begins with Jesus’ encouter with Pontius Pilate, the man who orders Jesus’ crucifixion. The Church of the Flagellation is built on the spot where Jesus was flogged by Roman soldiers before he carries the cross.

It’s said he falls three times during his walk.

Along the way, Jesus encounters several people (although some of these encounters are disputed):

• Mary – his mother
• Simon of Cyrene – he helps Jesus carry the cross
• Veronica – she wipes the sweat off of Jesus’ face, and so Jesus’ image was then supernaturally imprinted on the piece of cloth, now known as the Veil of Veronica
• the pious women – Jesus stops and gives a sermon

Eventually he makes his way to the location where he is nailed to the cross. The Church of the Holy Sepulchre is built on the spot where it is believed he was nailed to the cross, and his subsequent death.

This is supposedly the spot where Jesus dies on the cross (below)

He is then taken down from the cross and anointed on the stone slab below. Anointing is a ceremonial ritual where a person’s body is smeared in aromatic oil to introduce a divine influence on the body.

Finally he is laid to rest in his tomb.

Of course his body isn’t physically in there, because supposedly after his ressurection, he ascended to heaven.

The entire Way of the Cross and the Church of the Holy Sepulchre was extremely crowded and people lined up everywhere to pray in all the spiritual locations, like Jesus’ tomb, the home of the Virgin Mary, the Stone of Anointing, etc. People even touched all the surfaces that Jesus was said to have touched and I could see them in deep prayer.

Western / Wailing Wall

In Judaism, the Western Wall is one of its holiest sites. The actual holiest site lines behind the wall, the Temple Mount, but due to restrictions, Jews are not allowed to pray there, and thus the wall became the place where Jews went to pray.

Some Jews go on a pilgrimage to the Western Wall, some spend hours praying there. If you look closely in the video below, there’s a fellow running in circles and singing while people around him are rubbing their beards against the wall.

The Temple Mount

The Temple Mount is a flat plaza built on top of four retaining walls (the Western Wall among them). Although Jews are not allowed to enter for prayer (e.g. praying, singing, or other religious displays), people are allowed to enter the area as tourists.

The Dome of the Rock is one of the Islamic structures built on the Temple Mount. Unfortunately, non Muslims are not allowed to enter. Inside the dome is the Foundation Stone, and has religious significance to both Jews and Muslims.

Yad Vashem

This is Israel’s official memorial to the victims of the Holocaust. The entire memorial consists of a museum dedicated to the history of Jewish persecution throughout Nazi Germany and the places it conquered.

The eternal flame honours the victims of the holocaust. In front of it is a stone crypt containing the ashes of the victims.

The Hall of Names pictured above contains the the names of millions of Holocaust victims. The shelves around the room contain the names, while the cone above display photographs of the victims. The people standing in the photo are all Israeli soldiers – Jerusalem had a huge police presence with a lot of them openly carrying assault rifles (I felt very safe). Even some men in public that I saw had buzz cuts – presumably they are/were in the military. A few days before we arrived, there was a terrorist attack where a driver rammed a car into Israeli soldiers.

This train car is an example of the cattle cars that Nazi Germany used to perpretrate the Holocaust.

The Garden Tomb

Some sects of Christianity don’t believe that the Church of the Holy Sepulchre contains the real tomb of Jesus Christ. They assert that the real tomb is actually elsewhere, which they dubbed the Garden Tomb

Outside Jerusalem’s old town

Because Israel has so many Jewish people, McDonald’s started a special chain that serves only Kosher food. Even though it’s kosher, it tastes the exact same as regular McDonald’s which is pretty amazing for what it is.

Oskar Schindler is famous for saving 1200 Jews during the holocaust. He is now buried in Jerusalem. Putting stones and pebbles on the grave is an ancient Jewish tradition to honour the deceased.

There are also a lot of stray cats everywhere! I didn’t see any dogs though, just lots and lots of stray cats everywhere. People must take care of them though because they all look pretty well groomed.

Photo album: here

Originally, we had planned on visiting Sedan too. This was where the Germans made their initial breakthrough into France that eventually led to the French surrender. We intended to go to the Museum of the Last Cartridge, the local museum there, thinking that it was about the World War II battle, but actually it was about the Battle of Bazeilles during the Franco Prussian War (which I had never heard of before). In the end, we didn’t have time for it anyway so it was okay that we didn’t go.

The Maginot Line

Not far from Sedan, was a preserved portion of the Maginot Line in northeastern France, known as the Ouvrage La Ferté. The Maginot Line was a series of defensive fortifications stretching along the French border from Luxembourg to Italy built after World War I to protect France from a future German invasion. The location at the Ouvrage La Ferté saw the heaviest fighting during the Battle of France in World War II. It eventually was overwhelmed by German forces and its entire garrison was killed.

It’s exterior still shows the damage from the battle and grass has grown over the craters that were once there. It is possible to tour the inside of the bunker, but it is only available to large group tours.

Driving through the area, it’s pretty common to still see bunkers on the side of the road.

The Ouvrage La Ferté is in a pretty remote location, which makes sense considering it’s a defensive fortification, and because of the rain the night before, we ended up driving on some flooded roads, and even narrow farm roads that even Google Maps didn’t have a name for.

Verdun

From Ouvrage La Ferté, we drove to Verdun. Verdun was the site of another major battle in World War I, and to remember the fallen soldiers, a memorial containing their skeletal remains was constructed.

Unbeknownst to us, the ossuary was actually closed when we arrived, so we never got to go inside. We could only peek through the windows and see was a blurry view of stacks of bones. In front of the monument lies a military cemetery.

Nearby the ossuary is the actual fort that played a role in the Battle of Verdun. The fort fell to the Germans without a fight since the French had abandoned the fort thinking that the fort would have been ineffective against the heavy artillery that the Germans were using. Eventually, the fort was recaptured.

The road leading up to the fort was interesting too because some of the old trenches were preserved. The zig zag of the trenches can still be seen. Its purpose was to ensure that shrapnel exploding inside the trench would be contained. A straight trench would have allowed a clear path for the shrapnel to fly through more of the trench.

From there we drove three and a half hours to Strasbourg, where we’d start our fourth day of our road trip. That’s all for now!

• Maginot Line
• Verdun

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

1. Install Docker on your machine
2. Get a Docker image for a CS 1.6 server (I created this one, which is based off of an existing one. Mine has:
   • A lot of maps
   • Metamod
   • AMXModX (with high ping kicker, podbot control menu, round money, rock the vote, and admin all in one)
   • Podbot
3. Customise the server (e.g. editing the server.cfg, amxx.cfg, and other config files, etc.)
4. Start it up! (the README.md in the above linked Git repos has more info on this)

As far as ports go, I only needed to forward 27015 on my machine, but your mileage may vary. Others have reported that some more ports must also be forwarded on some machines.

Then optionally, if you’re running Ubuntu and you want this server to start up like a service via systemd, you’ll need this:

1. An executable script with path /usr/local/bin/hlds with contents (make sure the DIR variable matches your installation directory):

#!/bin/sh

# Do not change this path
PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin

# The path to the game you want to host. example = /home/newuser/dod
DIR=/opt/cs-16-server/bin
DAEMON=./server

start()
{
    echo  -n "Starting HLDS"
    if [ -e $DIR ]; then
        cd $DIR
        $DAEMON start
    else
        echo "No such directory: $DIR!"
    fi
}

stop()
{
    echo -n "Stopping HLDS"
    if [ -e $DIR ]; then
        cd $DIR
        $DAEMON stop
    else
        echo "No such directory: $DIR!"
    fi
}

reload()
{
    echo -n "Restarting HLDS"
    stop
    sleep 1
    start
}

case "$1" in
    start|stop|reload)
        "$1"
        ;;
    *)
        echo  "Usage: $ 0 {start | stop | reload | status}"
        exit  1
        ;;
esac

exit  0

2. A script with path /etc/systemd/system/hlds.service with contents:

[Unit]
Description=HLDS

[Service]
Type=oneshot
ExecStart=/usr/local/bin/hlds start
ExecStop=/usr/local/bin/hlds stop
ExecReload=/usr/local/bin/hlds reload
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

3. Then execute:

systemctl daemon-reload
systemctl enable hlds
service hlds start

Feel free to check out my server that’s running right now with the same Docker image! Here’s the command to connect via the console.

connect henrypoon.com:27015

The nice thing about all of this is that I can push a code change to git, and Jenkins can build it, run through all the tests and then deploy to production automatically.

Layout of a pipeline script

Pipeline scripts are written in Groovy, which is a variant of Java. In general, a pipeline script is laid out like this:

node {
    def SOME_CONSTANT = "whatever"
    ...

    stage('some stage name like Build') {
        // Stuff to do as a part of this stage
    }

    stage('another stage') {
        // More stuff
    }

    ...
}

Each stage represents a stage in the pipeline (e.g. building, beta deployment, prod deployment etc.)

Defining some constants

First, a list of constants can be defined that can be used throughout the pipeline so that if the pipeline script gets reused somewhere, only these constants have to be changed. I’m not aware of anything that lets me reuse a pipeline in Jenkins without copying and pasting the code somewhere else so for now I’ll have to live with copying and pasting.

My project uses Maven so I got Jenkins to download its own copy of Maven that it can use to execute builds and have defined it as a constant. The name I’ve given it in the Jenkins Global Tool Configuration is “Maven 3.3.9” exactly. My project also uses Tomcat so there are some Tomcat specific things in there that may or may not be relevant to your use case.

def MAVEN_HOME = tool 'Maven 3.3.9'
    def WORKSPACE = pwd()

    def PROJECT_NAME = "name-of-project"
    def WAR_PATH_RELATIVE = "App/target/${PROJECT_NAME}.war"
    def WAR_PATH_FULL = "${WORKSPACE}/${WAR_PATH_RELATIVE}"
    def TOMCAT_CTX_PATH_BETA = "Tomcat-context-path-for-the-beta-stage"
    def TOMCAT_CTX_PATH_PROD = "Tomcat-context-path-for-the-prod-stage"
    def GIT_REPO_URL = "URL-to-git-repo-ending-in-.git"

Preparation Stage

First, the code has to be retrieved from the repository before it gets built. Jenkins allows storing username/password pairs so that they can be referenced without having to write out the password in plaintext. Jenkins uses a “credential ID” for this.

    stage('Preparation') {
        git branch: "master",
        credentialsId: "credentials-ID-stored-in-Jenkins-that-can-access-the-git-repo",
        url: "${GIT_REPO_URL}"
    }

Build Stage

Next, the code must be built and unit tested. “mvn clean install” will do just that (depending on what you want, you can always put in a different maven goal). The junit command is just there to take the resulting XML that gets generated during the build process and posts a graph of how many tests were run for each build.

    stage('Build') {
        sh "'${MAVEN_HOME}/bin/mvn' clean install"
        junit '**/target/surefire-reports/TEST-*.xml'
    }

Beta Stage

Once the build succeeds, you’ll want to deploy it to a beta environment, so integration tests can happen. The following happens at this stage:

1. Get the right credentials to get permissions to Tomcat
2. Call the deploy method to deploy the war file in Tomcat (more on that later)
3. If the deployment fails for whatever reason, print out the deployment log for debugging and fail the build
4. If the deployment succeeds, run the integration tests (the command to do this may differ based on use case)

    stage('Beta') {
        withCredentials([[$class: 'UsernamePasswordMultiBinding',
            credentialsId: 'credential-id-for-tomcat',
            usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD']]) {
                // Password is available as an env variable, but will be masked 
                // if you try to print it out any which way
                def output = deploy(WAR_PATH_FULL, TOMCAT_CTX_PATH_BETA,
                        env.USERNAME, env.PASSWORD)
                if (output.contains("FAIL - Deployed application at context path " + 
                        "/${TOMCAT_CTX_PATH_BETA} but context failed to start")) {
                    echo "----- Beta deployment log -----"
                    echo output
                    echo "-------------------------------"
                    currentBuild.result = 'FAILURE'
                    error "Beta stage deployment failure"
                }
            }

        echo "Running integration tests"
        sh "'${MAVEN_HOME}/bin/mvn' -Dtest=*IT test"
        junit '**/target/surefire-reports/TEST-*.xml'
    }

The deploy method is what takes care of the actual deployment to Tomcat, which is how the Jenkins build tells Tomcat about the newly built war file. The deploy method is below (be sure to change the server IP and port). Alternatively, I could have built my project as an embedded jar file, but that has a different challenge in figuring out how to get Jenkins to tell the OS to execute the newly built jar file as a particular user.

1. Based on the Tomcat context path, decide whether a beta or production deployment is happening
2. Make a copy of the build war file and add .prod or .beta to the end of it so as to keep the original
3. Set the Spring profile to use on the newly copied war file (more on that later)
4. Call the curl command to do the actual deployment to Tomcat (more on that later)

def deploy(warPathFull, tomcatCtxPath, username, password) {
    def envSuffix = ""
    def isBeta = tomcatCtxPath.contains("beta")
    if (isBeta) {
        envSuffix = "beta"
    } else {
        envSuffix = "prod"
    }
    sh script: "cp ${warPathFull} ${warPathFull}.${envSuffix}" 
    setSpringProfile(warPathFull, isBeta)
    def output = sh script: "curl --upload-file '${warPathFull}.${envSuffix}' " +
            "'http://${username}:${password}@localhost:8081/manager/text/deploy" + 
            "?path=/${tomcatCtxPath}&update=true'", returnStdout: true
    return output
}

In the case of my project, I’m building a single war file that does not have a Spring profile (beta/prod) defined. This means that I have to manually define this before I deploy the app to Tomcat since there are some things that differ between beta and prod like database URL’s. To do this, I wrote a method that opens the war file like a zip (jar/war files are zip files) and adds a line to my application.properties to define a Spring profile.

Admittedly, doing this zip file manipulation seems kind of hacky. Alternatively, I could have defined my build such that I had a separate beta build and a prod build to avoid modifying the zip file, but the drawback is that I’d then have to build my code twice.

def setSpringProfile(warPathFull, isBeta) {
    def zipFileFullPath = warPathFull + "." + (isBeta ? "beta" : "prod")
    def zipIn = new File(zipFileFullPath)
    def zip = new ZipFile(zipIn)
    def zipTemp = File.createTempFile("temp_${System.nanoTime()}", 'zip')
    zipTemp.deleteOnExit()
    def zos = new ZipOutputStream(new FileOutputStream(zipTemp))
    def toModify = "WEB-INF/classes/application.properties"

    for(e in zip.entries()) {
        if(!e.name.equalsIgnoreCase(toModify)) {
            zos.putNextEntry(e)
            zos << zip.getInputStream(e).bytes
        } else {
            zos.putNextEntry(new ZipEntry(toModify))
            zos << zip.getInputStream(e).bytes
            zos << ("\nspring.profiles.active=" + (isBeta ? "beta" : "prod")).bytes
        }
        zos.closeEntry()
    }

    zos.close()
    zipIn.delete()
    zipTemp.renameTo(zipIn)
}

A curl command to Tomcat is what actually does the deployment. To deploy a file to Tomcat, do the following below. This will deploy the war file to Tomcat and instantly run it, thus it will be accessible at the given context path.

curl --upload-file 'path-to-war-file' http://username:password@server-address:port/manager/text/deploy?path=/tomcat-context-path&update=true

Prod Stage

The same kind of stuff happens in the prod stage as in the beta stage with a few exceptions. The following happens at this stage:

1. Get the right credentials to get permissions to Tomcat
2. Call the deploy method to deploy the war file in Tomcat (except this time it is prod)
3. If the deployment fails for whatever reason, print out the deployment log for debugging and roll back the deployment
4. If the deployment succeeds, save the build files, and then the pipeline is finished. Alternatively, smoke tests can be run at this point, but I did not implement this in my project

Rollback is important because if the deployment fails, you don’t want to be stuck with a broken environment. Since build artifacts are saved on successful deployments, these same artifacts can be brought back if future deployments fail. This means they can be redeployed so that the code can be fixed before another deployment happens.

    stage('Prod') {
        withCredentials([[$class: 'UsernamePasswordMultiBinding',
            credentialsId: 'credential-id-for-tomcat',
            usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD']]) {
                // Password is available as an env variable, but will be masked 
                // if you try to print it out any which way
                def output = deploy(WAR_PATH_FULL, TOMCAT_CTX_PATH_PROD, env.USERNAME, env.PASSWORD)
                if (output.contains("FAIL - Deployed application at context path " + 
                        "/${TOMCAT_CTX_PATH_PROD} but context failed to start")) {
                    echo "Prod stage deployment failure, rolling back deployment"
                    echo "----- Prod deployment log -----"
                    echo output
                    echo "-------------------------------"
                    step([$class: 'CopyArtifact',
                            filter: "${WAR_PATH_RELATIVE}",
                            fingerprintArtifacts: true,
                            projectName: "${PROJECT_NAME}",
                            target: "${WAR_PATH_RELATIVE}.rollback"])
                    deploy(WAR_PATH_FULL + ".rollback/" + WAR_PATH_RELATIVE,
                            TOMCAT_CTX_PATH_PROD, env.USERNAME, env.PASSWORD)
                    currentBuild.result = 'FAILURE'
                    error "Prod deployment rolled back"
                } else {
                    archiveArtifacts artifacts: "${WAR_PATH_RELATIVE}*", fingerprint: true
                }
            }
    }

At the end you get to have something like this:

That pretty much sums up the whole Jenkins pipeline that I’ve been using lately for Spring projects!

Travel tip: THERE IS UBER IN KRAKOW!!! To go from the airport to the old town, it costed only 25.46 PLN, which is not even $7 USD to go about 12km. That total was split by 3 people, so that’s about $2-something per person.

Our hostel was in the old town, and was in walking distance to the market square.

South of the old town is Wawel Castle.

And it’s got a great view of the Vistula River. It’s a got a great bike/jogging path that runs along it too.

We went on a walking tour to the old Jewish quarter. Since the war, it no longer housed the vibrant Jewish community that once existed.  The Old Synagogue, built in the 15th century still stands today.

The former ghetto now looks like this. Each chair represents 1000 victims.

The tour ended at the former Schindler Factory. It is now the site of museums for art and the history of Krakow. One of the exhibits is a cable car that used to run through the city. The sign says “Use by Jews forbidden”. It’s one thing to hear about what the tour guide says about the holocaust, but this sign was much much more impactful.

A less depressing topic: food. I can’t go to a new place without drinking their beer. I definitely like it a lot better than the beers I can get in North America. And then there’s bread. I really like bread. A local brand of orange juice, called Cappy was amazing too.

Somebody also told me to try perogies, but perogies to me are alright I guess. I also ate some deep fried calf brain. I would not eat that again. One of the restaurants we went to was called Wierzynek, and the cool thing about it is that it’s been around since 1364!

Link to photo album: here

A few days ago, I had the opportunity to go back to my old high school and present to students about studying engineering (link to presentation below), and to help guide them with their career choices.  The idea was to communicate:

• What engineering is as a profession
• What engineering is about
• That they should consider it as a career

At the same time, it wasn’t meant to “persuade” them to study engineering, but more like show them what it’s about so that they can make a more informed decision when they choose their university majors.  I also wanted to tell them this as general advice:

• Do what you’re interested in
• Nothing worth doing is ever easy
• Don’t do it just for the money

Overall, the students seemed to be receptive to what I had to say, and had good questions to ask me about my experiences.  Hopefully, I helped guide them to make a career choice for themselves!

Link to the presentation: here

Fun fact: Hawaii is not part of North America, but rather Oceania.  Already on the flight in, Hawaii already looks beautiful.

On the North Shore of the island, sea turtles sometimes just chill out on shore.  They are endangered because people wanted to eat them and use their shells for superstitious medicine.  It is illegal to touch them and there is a fine for it if caught.

Here’s a picture of our nice rental car – a BMW 535i.  Notice how there isn’t a front license plate (not legal)

Parts of Oahu’s coastline has lots of these oddly shaped rocks (possibly some volcanic rock?)

There’s also cool rock formations like this one at Laie Point.  We saw people here fishing, and jumping into the water from the cliff side – looks dangerous, but super fun.

For hikes, not many people know about the Puu O Mahuka State Monument, where there is a semi-hidden path that leads to a really good view of Waimea.

There’s also the Pillbox Hike near Lanikai beach, which is a bit more touristy, but the view up there is really nice too.

Another well-known hike is the Diamond Head hike, which starts at the base of a crater all the way up to the top edge of it.  From there, there is a good view of Waikiki and the surrounding area.

Another hike, called the Makapuu Point Lighthouse Trail is another hike to see Oahu’s natural beauty.  At some parts of the hike, the mountain blocks the wind completely, so on a hot day, there is no breeze for cooling down, which makes this hike a little less enjoyable.

For a night view of Honolulu, we headed up to Roundtop Drive

This is the best food in Hawaii.  It’s called Poke.  It’s essentially raw fish with spices on it – absolutely delicious when it is fresh.  The ones here are from a place called Fresh Catch.

Of course, there is also Pearl Harbor, the site where the Japanese attacked the United States in 1942.

The USS Arizona Memorial is built on a sunken battleship, the USS Arizona.  Even now, pockets of oil still bubble to the surface.

At the Polynesian Cultural Center, people can learn about the Polynesians and experience their culture through stuff like dance performances.  Too bad I couldn’t get a picture of their actual theater performance, where they did crazy tricks with sticks lit on fire.

There is the stereotypical Luau, which is a buffet with a dinner performance (with more fire involved).  There’s good food like kalua pig, poke, salmon, chicken, etc.

One thing that really surprised me about Hawaii is the amount of wild chickens everywhere.  I even got woken up in the morning by a rooster’s call in the morning.

Other things to do in Hawaii that I recommend:

• Trying garlic shrimp from a food truck (like Fumi’s)
• Drinking out of a coconut (really stereotypical, but I’ve always wanted to try this!)
• Drinking an Otai (coconut and mango drink)

Things that I do not recommend:

• Driving too fast.  Police are EVERYWHERE and it is impossible to get away with breaking traffic rules.  I learned this the hard way.

Link to photo album: here