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

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!

This guide presents how to mimic the system used in professional karaoke establishments at home.  The software this system uses revolves around a Taiwanese program called JetKTV.  Much of the content from this guide was drawn from Chinese language websites discussing the usage of this program (scroll all the way down for References).    There is little literature on this subject in English and so this guide presents basically an English version of the reference sites plus a few added notes.

The program used is in Chinese, so people who are not fluent in Chinese may have a hard time navigating through the software.  Those who are brave enough to continue or have a basic knowledge of Chinese with better English fluency may find it helpful to see English instructions.  The Chinese sites on this subject are also written for older versions, and the setup procedure for those older versions are slightly different.

Contents

• Proposed Setup
• Setting Up JetKTV2010
• Inserting A New Song
• Inserting A New Artist
• Testing
• References

Proposed Setup

The proposed setup of all the hardware (TV’s, amps, computer, etc.) is in the diagram below.

The computer will play the chosen Karaoke videos and transmit the video signal to the TV (via extended display like in a dual monitor set up).  The computer’s audio will go to an amplifier or a mixer, which is then transmitted to a set of speakers.  Microphones are plugged into the amplifier/mixer is well so that the speakers can also play the sound picked up by the microphones.  Depending on the hardware, the cables could be different (some TV’s may not have HD output etc.)The  computer is the source of all the signals transmitted to the other devices and must be set up with the Karaoke software.

Setting up JetKTV2010

The PC will use the following software:

• JetKTV2010 (link)
• SongMgr (optional – not helpful on English language PC’s – more on that topic later)

It is helpful to set up the software using a dual monitor setup.  That way, it is easier to test without having to go and plug the computer to the TV each time.

Unzip the contents of the JetKTV2010 program in a folder and open JetKTV2010.exe.  The GUI buttons are for searching through the database (by looking for the artist, song name, etc.) to find the wanted song. Once a song is selected, it will be added to the list of songs to play just like the software at actual Karaoke establishments. The video will play in full screen on one monitor and the song picker GUI will say on another monitor.  To close the program, click on the top left corner of the GUI (hidden button).

Some of the software features in addition to searching and adding songs:

• Skipping songs
• Fast forwarding, pausing, etc.
• Switching from one audio channel to both audio channels (alternating between vocal on/off)

This program reads from a database that contains the song names, artists, language, etc.   Therefore, it does not come with songs.  Songs must be downloaded separately and added on.  These can come from existing DVD’s or YouTube.  The next section will explain how to populate the database.

Populating the Database

The SongMgr program mentioned above can add/remove contents from the database, but there are problems with it when using it on English language PC’s due to problems in encoding some of the Chinese characters.  Even Microsoft AppLocale fails to rectify the problems.  The solution is to use Microsoft Access to open up the database file directly and make changes.

Adding one song can seem like a lengthy process at the first try, but it will get easier as one becomes more familiar with the system.

Inserting A New Song

To insert a new song, one must navigate to the table where the songs are stored and then add an entry to it.

1. Open Song.mdbin the JetKTV program directory
2. When prompted for a password, input “tmwcmgumbonqd” without quotes
3. Navigate to the table Tbl_Song.  This is the table that records all the song entries.

Below is an explanation of each column:

• Song_ID: numerical identifier for each song (the program lists them as 5 digit numbers starting at 10000)
• Song_Title: song title
• Song_Singer: each singer has a unique number associated with them (see next section)
• Song_Singer (2nd one): the name of the artist in text
• Song_Word: number of characters in the song name
• Song_Type: a number representing a language (Mandarin,Taiwanese,Cantonese,Hakka Chinese,English,Japanese,Movies,Cartoons,Other  in that order starting from 1)
• Song_Volume: song volume, but not sure what units they are in.  Default value is 70.
• Song_Channel: the audio channel that does not have the vocal track. (1-Left, 2-Right, 3-Both)
• Song_FileName: filename of the video without the directory
• Song_Path: the directory to the file (could use absolute pathing only, but unsure of whether relative paths work)
• Song_Create: the time that the song was added in
• Song_Count: the play count of a song
• Song_Juyin: the Zhuyin characters representing the song title
• Song_Stroke: number of strokes in the first character of the song name

Some of the columns can be left out, but that means that it will not be possible to find a particular song using the omitted information.  For example, Song_Juyin can be left out for those who dont use the Zhuyin system, and that feature won’t be used for song searching anyway.

To add a song, fill out the following information at the minimum on one row:

• Song_ID (must be a unique number and should have five digits)
• Song_Title
• Song_Singer
• Song_Volume (70 is the default)
• Song_Channel
• Song_FileName
• Song_Path

For the Song_Singer information, refer to the next section.

Inserting A New Artist

Artist information is stored on a different table called Tbl_Singer

1. Open the table called Tbl_Singer
2. Fill out an entire row to add a new singer (see below for the reference for each information column)

Below is an explanation of each column:

• Singer_ID: unique identifier for each singer (this is the unique ID that is to put inserted in the Song_Singer column in Tbl_Song)
• Singer_Sex: singer gender (0-Female, 1-Male, 2-Group/Band)
• Singer_Name: artist name in text
• Singer_Juyin: the Zhuyin characters representing the artist name
• Singer_Stroke: number of strokes in the first character of the artist’s name

Testing

One a song or two has been entered into the database, one can test it by opening up the JetKTV program and trying to pick a song.  It is working when one screen shows the video playing and another screen showing the JetKTV GUI.

One can also try clicking the button labeled “導唱” to test if the audio channels are set up properly (toggling it turns on and off the vocals).

The next step would be to plug in the computer with all the television components and then trying it again.  Once everything works, the system is ready.

References

All reference sites are in Chinese

[1] 動手打造窮人 KTV <http://www.jetktv.ktvdiy.com/> [Update 2022 October: JetKTV seems to be defunct]

[2] [影音相關] JetKTV 輕鬆打造免費 KTV 點唱機 (進階設定篇) <http://www.soft4fun.net/video-related/%E5%BD%B1%E9%9F%B3%E7%9B%B8%E9%97%9C-jetktv-%E8%BC%95%E9%AC%86%E6%89%93%E9%80%A0%E5%85%8D%E8%B2%BB-ktv-%E9%BB%9E%E5%94%B1%E6%A9%9F-%E9%80%B2%E9%9A%8E%E8%A8%AD%E5%AE%9A%E7%AF%87.htm#doublescr>

[3] 峰網誌 JetKTV-DIY電腦點歌機..軟體篇 <http://www.wretch.cc/blog/Linpy/4853370>

Up until now, I’ve never opened an MMS successfully. My Internet settings on the phone were never set
probably plus I never bothered to do it. I also didn’t know the billing rates for opening them either.
But now, an opportunity arose for me to require MMS. The Deutsche Bahn has three options for distributing tickets purchased online. The first one is by printing them out, but I don’t have a printer. The second method is having them mailed to me, but that costs 3.50 euro. The third and best option, is to have them sent as MMS. Knowing that my phone, the P1i, has this ability, I looked for how to do it. After going through lots of Googling and reading through translated German sites, I finally figured it out.

Now, I use Vodafone in Germany, but this method may work on other providers even. I am also using GPRS, and not 3G (I don’t have a dataplan unfortunately). The way to do it is to register an account on Vodafone.de using your phone number. Obviously, if you use a different provider, you’d go to their website to make the account. I clicked through their services and found an option called the “HandyKonfigurator”. What it does is it sends me the proper settings required for my phone. I clicked through the dropdown boxes, found my phone and pressed continue. Vodafone then sent me a file that would inject the settings into my phone. They also sent me a PIN that I had to enter before my phone settings were changed. I did as I was asked, and now I can receive MMS messages!

Vodafone Internet Account Settings

• Address: event.vodafone.de
• No user name and password required
• IP Config and DNS Addresses are set to automatic
• Proxy Server: 139.7.29.17 at port 80

Vodafone MMS Account Settings

• Service Center Address: http://139.7.24.1/servlets/mms

http://www.windows7news.com/2009/02/01/automatic-logon-into-windows-7/