May 26, 2016
13:49 -0400
Hubert Chathi: Looking forward to @mec.ca opening in Kitchener
0 Comments
May 25, 2016
14:53 -0400
Hubert Chathi: migrated our @sbscalculus.com servers from @tutum.co to @kubernetes.io. #
0 Comments
May 24, 2016
11:55 -0400
Hubert Chathi: It's interesting that @kubernetes.io is a # project, but they do not use Google+.
0 Comments
May 13, 2016
09:19 -0400
Hubert Chathi: My whalebuilder package building tool is now in # #
0 Comments
May 6, 2016
09:51 -0400
Hubert Chathi: Wow. The Fort McMurray wildfire compared in area to various cities.
Via: reddit
0 Comments
April 29, 2016

Let's encrypt errata

10:06 -0400

Back in February, I posted about Automatic Let's Encrypt certificates on nginx. One of the scripts had a problem in that it downloaded the Let's Encrypt X1 intermediate certificate. Let's Encrypt recently switched to using their X3 intermidiate, which means that Firefox was unable to reach sites using the generated certificates, and Chrome/IE/Safari needed to make an extra download to verify the certificate.

Of course, instead of just changing the script to download the X3 certificate, it's best to automatically download the right certificate. So I whipped up a quick Python script, cert-chain-resolver-py (inspired by the Go version) that checks a certificate and downloads the other certificates in the chain.

I've updated my original blog post. The changed script is /usr/local/sbin/letsencrypt-renew, and of course you'll need to install cert-chain-resolver-py (the script expects it to be in /opt/cert-chain-resolver-py).

0 Comments
April 8, 2016

Antagonistic Co-operation

08:56 -0400

This article was originally written for our housing co-operative's newsletter. Even though it was written in the context of a housing co-operative, I think the idea is useful in other contexts as well.

-

The word "antagonistic" and its relatives generally have negative connotations. Nobody likes to be antagonized. In literature, the antagonist in a story works against the protagonist or main character, so we do not like to see the antagonist succeed. However, antagonism can be essential in some cases. Many of our muscles come in what are called "antagonistic pairs," without which you would not be able to move. Muscles can only pull (by contracting) and relax; muscles cannot push. If you only had biceps, you would only be able to bend your arm; you also need your triceps in order to be able to straighten your arm. Your basic movements rely on muscles that oppose each other, yet work together to allow you to walk, lift, or write.

But sometimes our muscles do not work as they should. If you have ever experienced a cramp, you know how painful this can be sometimes. A cramp happens when a muscle suddenly tightens and will not loosen. Many cases of back pain are also due to muscles that fail to relax as they should. Some people require regular massage therapy due to pain caused by tight muscles.

As a co-operative, we should strive to operate like a well functioning body. As members of our co-operative, we all have different opinions and priorities, and we pull our co-operative in different directions. Some people may be more focused on providing activities for our children, and some are more focused on helping our elders adapt to new challenges. Some people prefer to be frugal, while others may wish to spend money to improve the quality of life here. Some people value a strict adherence to our bylaws, while others adopt a more "live and let live" attitude. Each of these views is welcome in our co-operative, and we should celebrate our differences. Indeed, without different opinions pulling us in different directions, our co-operative would be as lifeless as a skeleton with no muscles.

But in order for our co-operative to get anywhere, we must be willing, not just to pull in the direction that we want to go, but also to sometimes let go when others are pulling in a different direction. Sometimes we must allow other members to go ahead with their opinions and priorities without getting in their way.

Unlike our bodies, however, our co-operative does not have a central "brain" coordinating our actions, telling us when to pull and when to let go. Instead we must, as a co-operative, come to an agreement among ourselves. We must communicate with each other, and come to understand the perspectives of other members. Then we can decide when each member should have an opportunity to pull so that we do not prevent our co-op from moving forward by pulling in opposite directions at the same time.

We often see people with opposing viewpoints as adversaries. But while we may be antagonistic, we can still be co-operative.

-

This article may be copied under the terms of the Creative Commons Attribution-ShareAlike license.

0 Comments
April 4, 2016
10:57 -0400
Hubert Chathi: With @cloudflare.com blocking @torproject.org users, I've disabled CloudFlare on most of my sites
0 Comments
March 28, 2016
12:59 -0400
Hubert Chathi: # learned how to climb stairs last night
0 Comments
March 23, 2016

leftpad improved

13:26 -0400

Improved versions of left-pad

Shorter version (removed unneeded variable, and change to for loop: 9 lines of code instead of 11):

module.exports = leftpad;

function leftpad (str, len, ch) {
  str = String(str);

  if (!ch && ch !== 0) ch = ' ';

  for (len -= str.length; len > 0; len--) {
    str = ch + str;
  }

  return str;
}

Faster version (only perform O(log n) concatenations, where n is the number of characters needed to pad to the right length):

module.exports = leftpad;

function leftpad (str, len, ch) {
  str = String(str);

  if (!ch && ch !== 0) ch = ' ';
  ch = String(ch);

  len -= str.length;

  while (len > 0) {
    if (len & 1) {
      str = ch + str;
    }
    len >>>= 1;
    ch += ch;
  }

  return str;
}

ES6 version (which may be faster if String.prototype.repeat is implemented natively):

module.exports = leftpad;

function leftpad (str, len, ch) {
  str = String(str);

  if (!ch && ch !== 0) ch = ' ';
  ch = String(ch);

  len -= str.length;

  if (len > 0) str = ch.repeat(len) + str;

  return str;
}

Of course, you could combine the last two by detecting whether String.prototype.repeat is defined:

module.exports = String.prototype.repeat ?
function leftpad (str, len, ch) {
  str = String(str);

  if (!ch && ch !== 0) ch = ' ';
  ch = String(ch);

  len -= str.length;

  if (len > 0) str = ch.repeat(len) + str;

  return str;
}
:
function leftpad (str, len, ch) {
  str = String(str);

  if (!ch && ch !== 0) ch = ' ';
  ch = String(ch);

  len -= str.length;

  while (len > 0) {
    if (len & 1) {
      str = ch + str;
    }
    len >>>= 1;
    ch += ch;
  }

  return str;
}

As with the original left-pad, this code is released under the WTFPL.

(See also pad-left, which uses another dependency (by the same author) for repeating strings)

0 Comments
March 16, 2016
17:02 -0400
Hubert Chathi: "When we started Apple, Steve Jobs and I talked about how we wanted to make blind people as equal and capable as sighted people, and you'd have to say we succeeded when you look at all the people walking down the sidewalk looking down at something in their hands and totally oblivious to everything around them!" - Steve Wozniak
0 Comments
February 25, 2016
11:11 -0500
Hubert Chathi: New ways to contact me: tox: 50A6B251E7B42A0B2FC8852D4B1E89BC2D71797F64B53E36A3F9365E381B8E6A9FFE72FC8756, Friendika/GNUSocial/Diaspora: https://social.uhoreg.ca/profile/hubert
0 Comments
February 18, 2016

Automating Let's Encrypt certificates on nginx

17:57 -0500

Let's Encrypt is a new Certificate Authority that provides free SSL certificates. It is intended to be automated, so that certificates are renewed automatically. We're using Let's Encrypt certificates for our set of free Calculus practice problems. Our front end is currently served by an Ubuntu server running nginx, and here's how we have it scripted on that machine. In a future post, I'll describe how it's automated on our Docker setup with HAProxy.

First of all, we're using acme-tiny instead of the official Let's Encrypt client, since it's much smaller and, IMHO, easier to use. It takes a bit more to set up, but works well once it's set up.

We installed acme-tiny in /opt/acme-tiny, and created a new letsencrypt user. The letsencrypt user is only used to run the acme-tiny client with reduced priviledge. In theory, you could run the entire renewal process with a reduced priviledge user, but the rest of the process is just basic shell commands, and my paranoia level is not that high.

We then install cert-chain-resolver-py into /opt/cert-chain-resolver-py. This script requires the pyOpenSSL library to be installed, so make sure that it's installed. On Debian/Ubuntu systems, it's the python-openssl package.

We created an /opt/acme-tiny/challenge directory, owned by the letsencrypt user, and we created /etc/acme-tiny with the following contents:

  • account.key: the account key created in step 1 from the acme-tiny README. This file should be readable only by the letsencrypt user.
  • certs: a directory containing a subdirectory for each certificate that we want. Each subdirectory should have a domain.csr file, which is the certificate signing request created in step 2 from the acme-tiny README. The certs directory should be publicly readable, and the subdirectories should be writable by the user that the cron job will run as (which does not have to be the letsencrypt user).
  • private: a directory containing a subdirectory for each certificate that we want, like we had with the certs directory. Each subdirectory has a file named privkey.key, which will be the private key associated with the certificate. To coincide with the common setup on Debian systems, the private directory should be readable only by the ssl-cert group.

Instead of creating the CSR files as described in the acme-tiny README, I created a script called gen_csr.sh:

#!/bin/bash
openssl req -new -sha256 -key /etc/acme-tiny/private/"$1"/privkey.pem -subj "/" -reqexts SAN -config <(cat /etc/ssl/openssl.cnf <(printf "[SAN]\nsubjectAltName=DNS:") <(cat /etc/acme-tiny/certs/"$1"/domains | sed "s/\\s*,\\s*/,DNS:/g")) > /etc/acme-tiny/certs/"$1"/domain.csr

The script is invoked as gen_scr.sh <name>. It reads a file named /etc/acme-tiny/certs/<name>/domains, which is a text file containing a comma-separated list of domains, and it writes the /etc/acme-tiny/certs/<name>/domain.csr file.

Now we need to configure nginx to serve the challenge files. We created a /etc/nginx/snippets/acme-tiny.conf file with the following contents:

location /.well-known/acme-challenge/ {
    auth_basic off;
    alias /opt/acme-tiny/challenge/;
}

(The "auth_basic off;" line is needed because some of our virtual hosts on that server use basic HTTP authentication.) We then modify the sites in /etc/nginx/sites-enabled that we want to use Let's Encrypt certificates to include the line "include snippets/acme-tiny.conf;".

After this is set up, we created a /usr/local/sbin/letsencrypt-renew script that will be used to request a new certificate:

#!/bin/sh
set +e

# only renew if certificate will expire within 20 days (=1728000 seconds)
openssl x509 -checkend 1728000 -in /etc/acme-tiny/certs/"$1"/cert.pem && exit 255

set -e
DATE=`date +%FT%R`
su letsencrypt -s /bin/sh -c "python /opt/acme-tiny/acme_tiny.py --account-key /etc/acme-tiny/account.key --csr /etc/acme-tiny/certs/\"$1\"/domain.csr --acme-dir /opt/acme-tiny/challenge/" > /etc/acme-tiny/certs/"$1"/cert-"$DATE".pem
ln -sf cert-"$DATE".pem /etc/acme-tiny/certs/"$1"/cert.pem
python /opt/cert-chain-resolver-py/cert-chain-resolver.py -o /etc/acme-tiny/certs/"$1"/chain-"$DATE".pem -i /etc/acme-tiny/certs/"$1"/cert.pem -n 1
ln -sf chain-"$DATE".pem /etc/acme-tiny/certs/"$1"/chain.pem
cat /etc/acme-tiny/certs/"$1"/cert-"$DATE".pem /etc/acme-tiny/lets-encrypt-x1-cross-signed.pem > /etc/acme-tiny/certs/"$1"/fullchain-"$DATE".pem
ln -sf fullchain-"$DATE".pem /etc/acme-tiny/certs/"$1"/fullchain.pem

The script will only request a new certificate if the current certificate will expire within 20 days. The certificates are stored in /etc/acme-tiny/certs/<name>/cert-<date>.pem (symlinked to /etc/acme-tiny/certs/<name>/cert.pem). The full chain (including the intermediate CA certificate) is stored in /etc/acme-tiny/certs/<name>/fullchain-<date>.pem (symlinked to /etc/acme-tiny/certs/<name>/fullchain.pem).

If you have pyOpenSSL version 0.15 or greater, you can replace the -n 1 option for cert-chain-resolver.py with something like -t /etc/ssl/certs/ca-certificates.crt, where /etc/ssl/certs/ca-certificates.crt should be set to the location of a set of trusted CA certificates in PEM format.

As-is, the script must be run as root, since it does a su to the letsencrypt user. It should be trivial to modify it to use sudo instead, so that it can be run by any user that has the appropriate permissions on /etc/acme-tiny.

the letsencrypt-renew script is run by another script that will restart the necessary servers if needed. For us, the script looks like this:

#!/bin/sh

letsencrypt-renew sbscalculus.com

RV=$?

set -e

if [ $RV -eq 255 ] ; then
  # renewal not needed
  exit 0
elif [ $RV -eq 0 ] ; then
  # restart servers
  service nginx reload;
else
  exit $RV;
fi

This is then called by a cron script of the form chronic /usr/local/sbin/letsencrypt-renew-and-restart. Chronic is a script from the moreutils package that runs a command and only passes through its output if it fails. Since the renewal script checks whether the certificate will expire, we run the cron task daily.

Of course, once you have the certificate, you want to tell nginx to use it. We have another file in /etc/nginx/snippets that, aside from setting various SSL parameters, includes

ssl_certificate /etc/acme-tiny/certs/sbscalculus.com/fullchain.pem;
ssl_certificate_key /etc/acme-tiny/private/sbscalculus.com/privkey.pem;

This is the setup we use for one of our server. I tried to make it fairly general, and it should be fairly easy to modify for other setups.

Update (Apr. 29, 2016): Let's Encrypt changed their intermediate certificate, so the old instructions for downloading the intermediate certificate are incorrect. Instead of using a static location for the intermediate certificate, it's best to use a tool such as https://github.com/muchlearning/cert-chain-resolver-py to fetch the correct intermediate certificate. The instructions have been updated accordingly.

0 Comments
February 3, 2016
14:03 -0500
Hubert Chathi: The fastest query is the one you don't do. Sped up the response time of some @sbscalculus.com pages from about 3s to about 0.3s by not fetching some irrelevant data. #
0 Comments
January 27, 2016

Automating browser-side unit tests with nodeunit and PhantomJS

11:24 -0500

I love unit tests, but they're only useful if they get run. For one of my projects at work, I have a set of server-side unit tests, and a set of browser-side unit tests. The server-side unit tests get run automatically on “git push`‘ via Buildbot, but the browser-side tests haven't been run for a long time because they don't work in Firefox, which is my primary browser, due to differences in the way it iterates through object keys.

Of course, automation would help, in the same way that automating the server-side tests ensured that they were run regularly. Enter PhantomJS, which is a scriptable headless WebKit environment. Unfortunately, even though PhantomJS can support many different testing frameworks, there is no existing support for nodeunit, which is the testing framework that I'm using in this particular project. Fortunately, it isn't hard to script support for nodeunit.

nodeunit's built-in browser support just dynamicall builds a web page with the test results and a test summary. If we just ran it as-is in PhantomJS, it would happily run the tests for us, but we wouldn't be able to see the results, and it would just sit there doing nothing when it was done. What we want is for the test results to be output to the console, and to exit when the tests are done (and exit with an error code if tests failed). To do this, we will create a custom nodeunit reporter that will communicate with PhantomJS.

First, let's deal with the PhantomJS side. Our custom nodeunit reporter will use console.log to print the test results, so we will pass through console messages in PhantomJS.

page.onConsoleMessage = function (msg) {
    console.log(msg);
};

We will use PhantomJS's callback functionality to signal the end of the tests. The callback data will just be an object containing the total number of assertions, the number of failed assertions, and the time taken.

page.onCallback = function (data) {
    if (data.failures)
    {
        console.log("FAILURES: " + data.failures + "/" + data.length + " assertions failed (" + data.duration + "ms)")
    }
    else
    {
        console.log("OK: " + data.length + " assertions (" + data.duration + "ms)");
    }
    phantom.exit(data.failures);
};

(Warning: the callback API is marked as experimental, so may be subject to change.)

If the test page fails to load for whatever reason, PhantomJS will just sit there doing nothing, which is not desirable behaviour, so we will exit with an error if something fails.

phantom.onError = function (msg, trace) {
    console.log("ERROR:", msg);
    for (var i = 0; i < trace.length; i++)
    {
        var t = trace[i];
        console.log(i, (t.file || t.sourceURL) + ': ' + t.line + t.function ? t.function : "");
    }
    phantom.exit(1);
};
page.onError = function (msg, trace) {
    console.log("ERROR:", msg);
    for (var i = 0; i < trace.length; i++)
    {
        var t = trace[i];
        console.log(i, (t.file || t.sourceURL) + ': ' + t.line + t.function ? t.function : "");
    }
    phantom.exit(1);
};
page.onLoadFinished = function (status) {
    if (status !== "success")
    {
        console.log("ERROR: page failed to load");
        phantom.exit(1);
    }
};
page.onResourceError = function (resourceError) {
    console.log("ERROR: failed to load " + resourceError.url + ": " + resourceError.errorString + " (" + resourceError.errorCode + ")");
    phantom.exit(1);
};

Now for the nodeunit side. The normal test page looks like this:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <title>ML Editor Test Suite</title>
    <link rel="stylesheet" href="stylesheets/nodeunit.css" type="text/css" />
    <script src="javascripts/module-requirejs.js" type="text/javascript"></script>
    <script src="javascripts/requirejs-config.js" type="text/javascript"></script>
    <script data-main="test" src="javascripts/require.js" type="text/javascript"></script>
  </head>
  <body>
    <h1 id="nodeunit-header">ML Editor Test Suite</h1>
  </body>
</html>

If you're not familiar with RequireJS pages, the <script data-main="test" src="javascripts/require.js" type="text/javascript"></script> line means that the main JavaScript file is called "test.js". We want to use the same script file for both a normal browser test and the PhantomJS-based test, so in PhantomJS, we will set window.nodeunit_reporter to our custom reporter. In "test.js", then, we will check for window.nodeunit_reporter, and if it is present, we will replace nodeunit's default reporter. Although there's no documented way of changing the reporter in the browser version of nodeunit, looking at the code, it's pretty easy to do.

if (window.nodeunit_reporter) {
    nodeunit.reporter = nodeunit_reporter;
    nodeunit.run = nodeunit_reporter.run;
}

(Disclaimer: since this uses an undocumented interface, it may break some time in the future.)

So what does a nodeunit reporter look like? It's just an object with two items: info (which is just a textual description) and run. run is a function that calls the nodeunit runner with a set of callbacks. I based the reporter off of a combination of nodeunit's default console reporter and its browser reporter.

window.nodeunit_reporter = {
    info: "PhantomJS-based test reporter",
    run: function (modules, options) {
        var opts = {
            moduleStart: function (name) {
                console.log("\n" + name);
            },
            testDone: function (name, assertions) {
                if (!assertions.failures())
                {
                    console.log("✔ " + name);
                }
                else
                {
                    console.log("✖ " + name);
                    assertions.forEach(function (a) {
                        if (a.failed()) {
                            console.log(a.message || a.method || "no message");
                            console.log(a.error.stack || a.error);
                        }
                    });
                }
            },
            done: function (assertions) {
                window.callPhantom({failures: assertions.failures(), duration: assertions.duration, length: assertions.length});
            }
        };
        nodeunit.runModules(modules, opts);
    }
};

Now in PhantomJS, I just need to get it to load a modified test page that sets window.nodeunit_reporter before loading "test.js", and voilà, I have browser tests running on the console. All that I need to do now is to add it to my Buildbot configuration, and then I will be alerted whenever I break a browser test.

The script may or may not work in SlimerJS, allowing the tests to be run in a Gecko-based rendering engine, but I have not tried it since, as I said before, my tests don't work in Firefox. One main difference, though, is that SlimerJS doesn't honour the exit code, so Buildbot would need to parse the output to determine whether the tests passed or failed.

0 Comments
January 18, 2016

When native code is slower than interpreted code

16:56 -0500

At work, I'm working on a document editor, and it needs to be able to read in HTML data. Well, that's simple, right? We're in a browser, which obviously is able to parse HTML, so just offload the HTML parsing to the browser, and then traverse the DOM tree that it creates.

var container = document.createElement("div");
container.innerHTML = html;

The browser's parser is native code, built to be robust, well tested. What could go wrong?

Unfortunately, going this route, it ended up taking about 70 seconds to parse a not-very-big document on my 4 year old laptop. 70 seconds. Not good.

Switching to a JavaScript-based HTML parser saw the parsing time drop down to about 9 seconds. Further code optimizations in other places brought it down to about 3 seconds. Not too bad.

So why is the JavaScript parser faster than the browser's native parser? Without digging into what the browser is actually doing, my best guess is that the browser isn't just parsing the HTML, but is also calculating styles, layouts, etc. This guess seems to be supported by the fact that not all HTML is parsed slowly; some other HTML of similar size is parsed very quickly (faster than using the JavaScript-based parser). But it can't be the whole story, because the browser is able to display that same HTML fairly quickly.

I may have to do some further investigations, but I guess the moral of the story is to not assume that offloading work is the fastest solution.

0 Comments
December 30, 2015
22:08 -0500
Hubert Chathi: RIP Ian Murdock, # founder
0 Comments
December 29, 2015
18:05 -0500
Hubert Chathi: Springer is providing free downloads of books older than 10 years, which includes my conference paper. http://www.springerlink.com/content/pbxglecx113c6axl/?p=4c7461a8f89141dda0a4664bc0d413fc&pi=1
0 Comments
December 22, 2015
19:13 -0500
Hubert Chathi: Congratulations to @spacex.com. I never thought that there could be so much excitement over seeing something stand still.
0 Comments
December 18, 2015
11:35 -0500
Hubert Chathi: Out of context comment of the day: "do nothing, since we don't care about users"
0 Comments