<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Dial>+1971221xxxx</Dial>
</Response>

Back to SMS forwarding… we don’t get many SMS messages and instead of warning us via email, SendGrid just closed the account. So for some months we weren’t getting SMS messages forwarded to our Google Group inbox. Even though I added a credit card, they could not reactivate it, so here I am with a port to Mailgun.

So, same basic steps as Phil’s blog post except Functions/Functions are now Functions/Services which you can find here.

Create a new function at path /forward.

Under Dependencies add mailgun.js version 4.1.1 and form-data version 4.0.0.

Under Environment Variables add MAILGUN_DOMAIN, MAILGUN_API_KEY, FROM_EMAIL_ADDRESS, and TO_EMAIL_ADDRESS.

I based this function body on the Mailgun example:

exports.handler = function(context, event, callback) {
  const API_KEY = context.MAILGUN_API_KEY;
  const DOMAIN = context.MAILGUN_DOMAIN;

  const formData = require('form-data');
  const Mailgun = require('mailgun.js');

  const mailgun = new Mailgun(formData);
  const client = mailgun.client({username: 'api', key: API_KEY});

  const messageData = {
    from: context.FROM_EMAIL_ADDRESS,
    to: context.TO_EMAIL_ADDRESS,
    subject: `New SMS message from: ${event.From}`,
    text: event.Body
  };

  client.messages.create(DOMAIN, messageData)
  .then((res) => {
      let twiml = new Twilio.twiml.MessagingResponse();
      callback(null, twiml);
  })
  .catch((err) => {
    console.error(err);
    callback(err);
  });
};

Make sure you hooked it up to the correct phone number, then test it out by sending an SMS message to your Twilio number. If you need to debug, look in the Messaging logs in Twilio and the Mailgun Sending/Logs.

If you run into issues or have feedback, please don’t hesitate to send me an email if you know it, or mention me on Twitter. Thanks!

I’ll leave it to the reader to get efm-langserver installed, but I wanted to share my config. I use ~/.config/efm-langserver/config.yaml to configure formatters & linters, and I configure efm in Neovim in ~/.config/nvim/init.lua. Here are the relevant parts:

efm-langserver config

version: 2

tools:
  tailwind-class-sort: &tailwind-class-sort
    format-command: 'rustywind --stdin'
    format-stdin: true

languages:
  html:
    - <<: *tailwind-class-sort

neovim lua config

lspconfig.efm.setup({
  filetypes = {"html"},
  init_options = {documentFormatting = true},
})

Check out my dotfiles repo commit and you can view more of the files to see how they’re all put together. Now, when you write the file, you’ll get automatic class sorting. Fun stuff!

Hex, the package manager for Elixir is very well thought out, but there are things I’m still being introduced to, like private organizations. There’s a beta I’m trying out, and it requires me to use a hex org key, which is fine, but how do I securely store it in Heroku such that it’s available when installing packages?

My first attempt was to set the hook_pre_fetch_dependencies hook of the excellent buildpack for Heroku like so:

hook_pre_fetch_dependencies="mix hex.organization auth acme --key $HEX_ORG_KEY_FOR_ACME"

I pushed to Heroku and…

-----> Executing hook before fetching app dependencies: mix hex.organization auth acme --key

** (Mix) Could not invoke task "hex.organization": 1 error found!

--key : Missing argument of type string

Luckily, I had already set up a postdeploy script for Heroku’s app.json so I had that method in mind, however, there wasn’t a hook in that lifecycle that made sense for me to use. But, mixing the two approaches did seem like something worth trying, and this is what ended up working.

In ./bin/predeps

#!/bin/bash

mix hex.organization auth acme --key "$HEX_ORG_KEY_FOR_ACME"

In elixir_buildpack.config

hook_pre_fetch_dependencies="./bin/predeps"

Worked, and feels clean enough!

Previously

I would turn to Nginx, where I would apt-get install nginx and then go install nginx_ensite then setup a config and some SSL certs, like so:

# /etc/nginx/sites-enabled/inquicker

server {
  listen 80;
  server_name inquickerlocal.com;

  return 301 https://iqapp.inquickerlocal.com$request_uri;
}

server {
  listen 80;
  server_name *.inquickerlocal.com;

  return 301 https://${host}${request_uri};
}

server {
  listen 443 ssl;
  server_name inquickerlocal.com www.inquickerlocal.com;

  include /etc/nginx/iqapp-ssl-settings.conf;

  return 301 https://iqapp.inquickerlocal.com$request_uri;
}

server {
  listen 443 ssl;
  server_name *.inquickerlocal.com;

  include /etc/nginx/iqapp-ssl-settings.conf;

  root /path/to/iqapp/public;
  try_files $uri $uri/index.html @app;

  location @app {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header Host $host;
    proxy_redirect off;
    proxy_pass http://localhost:3000;
  }
}

I’d then have to go into that file and change things to work with my local setup, like

root /path/to/iqapp/public;

Ain’t nobody got time for that.

Enter Træfik.

Træfik (pronounced like traffic) is a modern HTTP reverse proxy and load balancer made to deploy microservices with ease.

It’s quite powerful, and you can find out all about it here. I’ll save you some time if you just want to set up a reverse proxy that also serves your local development site over SSL. This is our setup for a typical Rails app:

[web]
address = ":8080"

traefikLogsFile = "log/traefik.log"
accessLogsFile = "log/access.log"

defaultEntryPoints = ["http", "https"]
[entryPoints]
  [entryPoints.http]
  address = ":80"
    [entryPoints.http.redirect]
    entryPoint = "https"
  [entryPoints.https]
  address = ":443"
    [entryPoints.https.tls]
      [[entryPoints.https.tls.certificates]]
      certFile = "config/development-cert.pem"
      keyFile = "config/development-key.pem"

[file]

[backends]
  [backends.puma]
    [backends.puma.servers.rails]
      url = "http://127.0.0.1:3000"

[frontends]
  [frontends.my_app]
  entrypoints = ["https"]
  backend = "puma"
  passHostHeader = true
    [frontends.my_app.routes.all]
      rule = "HostRegexp:{subdomain:[a-z]+}.myapp.dev"

You can then run it with sudo traefik -c config/traefik.toml. You need the sudo to run on the privileged ports 80 and 443.

Let’s step through this, as it was a bit confusing to get it right.

Admin interface

[web]
address = ":8080"

Add this and you can browse to http://localhost:8080 to see Træfik’s web interface, which was actually handy in debugging this whole thing.

Log files

traefikLogsFile = "log/traefik.log"
accessLogsFile = "log/access.log"

I had a typo (frontend.my_app instead of frontends.my_app) and the access log file would show me the 404.

Entrypoints

defaultEntryPoints = ["http", "https"]
[entryPoints]
  [entryPoints.http]
  address = ":80"
    [entryPoints.http.redirect]
    entryPoint = "https"
  [entryPoints.https]
  address = ":443"
    [entryPoints.https.tls]
      [[entryPoints.https.tls.certificates]]
      certFile = "config/development-cert.pem"
      keyFile = "config/development-key.pem"

Define 2 entries, one that’s unsecured and redirects to the other secured one, and the secured one, secured by local cert and key files. We already had these dev certs (both in .pem formats) checked into our repo, so was simple to config. No need to sudo cp the files to somewhere in /etc/nginx/. Read more about entrypoints here.

Configuration backends

[file]

This took me a bit to figure out. I needed to specify that this file was where I was going to be defining the backends and frontends. Read more about it here.

Backends

[backends]
  [backends.puma]
    [backends.puma.servers.rails]
      url = "http://127.0.0.1:3000"

This section defines where traffic will be sent. I would start up Rails with a simple bundle exec rails s which defaults to port 3000. The puma and rails parts to the name are arbitrary. You can read more about backends here.

Frontends

[frontends]
  [frontends.my_app]
  entrypoints = ["https"]
  backend = "puma"
  passHostHeader = true
    [frontends.my_app.routes.all]
      rule = "HostRegexp:{subdomain:[a-z]+}.inquickerlocal.com"

So this took me a bit to figure out. I had to manually define the entrypoints which I thought would have been handled by defaultEntryPoints. Setting the backend makes sense, no problems there. passHostHeader is something we’ve had to do for a while, and the equivalent in Nginx is proxy_set_header Host $host;.

Now the frontend matchers… those are powerful. I chose the HostRegexp since I wanted to match on the subdomains. I lifted that straight from the docs, which you can find here.

Fin

I really like this setup, and while it is one more thing to run (sudo traefik) it’s all closer to the app and not some system-wide thing that’s in /etc. While Nginx has served me well for years, when it comes to local development I feel that Træfik is easier to set up and more powerful. It has fantastic Docker integration too, so one day I may need to explore that. Until then, I’m happy with this.

If you have any comments or suggestions, ping me on Twitter.

The first thing I tried was setting my connection to use Google’s DNS: 8.8.8.8 and 8.8.4.4 for ipv4 and 2001:4860:4860:8888 and 2001:4860:4860:8844 for ipv6.

No bueno.

Next step? Restart my computer.

No bueno.

I look around and see that there’s xfinitywifi and XFINITY networks, and I’m reminded that I can connect and that the XFINITY has a secure connection capability. Some googlin’ brings me to this support page. Well shit, Linux isn’t supported. I decide to give it a go anyway, and I’m presented with this screen:

I filled in those values based on the suggestions for Android from.

Well, initially I had No CA certificate is required but that didn’t feel right, so, more googlin’ and I found this AskUbuntu answer that suggested the AddTrust_External_Root.ca.

Lo and behold, it worked!

Now, am I 100% certain this is the same security level as what XFINITY is claiming on other platforms? No, but I’m like 95% and that’s good enough for the next few hours.

Update - Thanks to @variuxdavid for letting me know there’s a new CA certificate for later versions of Ubuntu: COMODO_RSA_Certification_Authority.crt. Screenshot updated!

Update - Chris Lopes reached out suggesting some improvements to this post. I’ve not been on Comcast for years, but this post keeps coming up in searches so I want to include his advice:

It seems that although GTC inner authentication works in order to connect to the hotspot, it does not (any longer?) allow actual use of the network without first logging in to the captive portal (Xfinity web login page), which is often hard to get to, believe it or not. The solution seems to be to use PAP instead, which solves this.

He also sent a link to an AskUbuntu answer that I hope can be helpful.

For those on Apple devices that might find their way here, I want to include Chris’s side note:

I also checked, and the .mobileconfig automatic configuration profiles that Xfinity provides to MacOS and iOS devices for use with the Hotspots now also list PAP as the inner authentication. There are files that you download and “install” on Apple devices to provision similar settings automatically as the ones we are discussing here. Xfinity interestingly generates some sort of separate credentials that are just for this purpose (totally different username/password than the one you would normally use). You can test this via the captive portal if you spoof your User Agent to be an apple device and have it generate the profile for you to download.

Some terms that I hope help you find your way here according to Chris:

• GTC
• PAP
• Tunneled TLS and TTLS
• EAP-TTLS
• Passpoint / Hotspot 2.0

I love receiving updates for this post! You keep sending them and I’ll keep updating.

The code has always been relatively simple:

defmodule Mix.Tasks.Jwt.Gen do
  use Mix.Task

  @shortdoc "Generates a JWT"

  @moduledoc """
  Generates a JWT far far into the future.

      mix jwt.gen
  """

  def run(_argv) do
    exp =   Joken.current_time + 1_000_000
    jti =   :rand.uniform
    iss =   "Jesse"

    jwt = Jwt.generate_jwt(%{exp: exp, jti: jti, iss: iss)
    Mix.shell.info(jwt)
  end
end

My test started off looking like this:

defmodule Mix.Tasks.Jwt.GenTest do
  use ExUnit.Case, async: true
  import ExUnit.CaptureIO

  describe "run/1" do
    test "prints a valid JWT" do
      jwt = capture_io(fn ->
        Mix.Tasks.Jwt.Gen.run([])
      end) |> String.trim

      token = Jwt.verify(jwt)
      refute token.errors
    end
  end
end

OK, this is fine, but there was an annoying side effect: the JWT was printed to :stdio when I ran the tests. I thought capture_io was supposed to actually capture and suppress the output… I was wrong. Or, I was missing something, and that ended up being the case.

I figured the best guidance I could get would be to see what Phoenix did, and I found an example in the routes task test:

test "format routes for specific router" do
  Mix.Tasks.Phx.Routes.run(["PhoenixTest.Web.Router"])
  assert_received {:mix_shell, :info, [routes]}               # <---- ooh!
  assert routes =~ "page_path  GET  /  PageController :index"
end

Yes, assert_received seems like a cleaner way to go. How did this change my tests?

defmodule Mix.Tasks.Jwt.GenTest do
  use ExUnit.Case, async: true

  describe "run/1" do
    test "prints a valid JWT" do
      Mix.Tasks.Jwt.Gen.run([])

      assert_received {:mix_shell, :info, [jwt]}    # pattern matching FTW

      token = Jwt.verify(jwt)
      refute token.errors
    end
  end
end

Much nicer!

Still though, the JWT was being printed to :stdio! I didn’t even know where to begin searching for how to handle this, so I went back to the Phoenix tests and noticed a helper was being required.

Code.require_file "../../../installer/test/mix_helper.exs", __DIR__

The key was at the top of that file!

# Get Mix output sent to the current
# process to avoid polluting tests.
Mix.shell(Mix.Shell.Process)

Once I changed my tests to include that, the unwanted output went away and I was happy with the shape of the tests.

# Get Mix output sent to the current
# process to avoid polluting tests.
Mix.shell(Mix.Shell.Process)

defmodule Mix.Tasks.Jwt.GenTest do
  use ExUnit.Case, async: true

  describe "run/1" do
    test "prints a valid JWT" do
      Mix.Tasks.Jwt.Gen.run([])

      assert_received {:mix_shell, :info, [jwt]}    # pattern matching FTW

      token = Jwt.verify(jwt)
      refute token.errors
    end
  end
end

I hope this saves you some trouble, and I’d love to hear how you test your tasks. Mention me on Twitter with a link to a Gist and I’ll add it here.

On options

I ended up using OptionParser so I could pass in exp, iss and jti. My final test looked like this:

Code.require_file("../mix_test_helper.exs", __DIR__)

defmodule Cerebro.Jwt.GenTest do
  use ExUnit.Case, async: true

  alias Mix.Tasks.Jwt.Gen

  describe "run/1" do

    setup context do
      Gen.run(context[:argv])

      assert_received {:mix_shell, :info, [jwt]}

      token = Cerebro.Jwt.verify_jwt(jwt)

      {:ok, claims: token.claims, token: token}
    end

    @tag argv: []
    test "prints a valid JWT with no args", %{token: token} do
      refute token.error
    end

    @tag argv: ["--exp", "123"]
    test "prints a valid JWT when passed an expiration", %{claims: claims} do
      assert_in_delta claims["exp"], Joken.current_time, 124
    end

    @tag argv: ["--jti", "fdsa"]
    test "prints a valid JWT when passed a jti", %{claims: claims} do
      assert claims["jti"] == "fdsa"
    end

    @tag argv: ["--iss", "logan"]
    test "prints a valid JWT when passed an iss", %{claims: claims} do
      assert claims["iss"] == "logan"
    end

    @tag argv: ["--token", "asdf"]
    test "prints a valid JWT when passed a token", %{claims: claims} do
      assert claims["token"] == "asdf"
    end
  end
end

I’m really happy with the way that turned out.

Update

Kelvin Stinghen clarified how one might use this Mix.shell(Mix.Shell.Process) from an umbrella application.

setup do
  Mix.shell(Mix.Shell.Process)
  on_exit fn ->
    Mix.shell(Mix.Shell.IO)
  end

  :ok
end

So, what is primitive obsession? Taken from C2 Wiki

Primitive Obsession is using primitive data types to represent domain ideas. For example, we use a String to represent a message, an Integer to represent an amount of money, or a Struct/Dictionary/Hash to represent a specific object.

We’re all guilty of this because in general we’re all kinda lazy. It’s certainly not a “rookie mistake”. Here it is in the latest version of redis.rb

# Get all the members in a set.
#
# @param [String] key
# @return [Array<String>]
def smembers(key)
  synchronize do |client|
    client.call([:smembers, key])
  end
end

Spot the issue?

Members of a set are a subset. A set’s members, by definition, are unique from one another. An Array is not a collection that enforces uniqueness. Have you ever done the following?

array_of_things << thing unless array_of_things.include?(thing)

Congratulations, you’ve just recreated Ruby’s Set class. That’s not a good thing. One reason why that’s not a good thing is (with the caveat that you should always do your own benchmarks) that checking to see if an array includes an object is O(n) where checking to see if a Set includes an object is O(1).

Let me clarify: at best and at worst an array is O(n) because it’s always O(n) for search. At best a Set, backed by a Hash, is O(1) which is quite good, O(n) at worst.

So there are consequences to using the wrong type, not just from a congnitive point of view but performance as well. Ok, let’s leave Array/Set alone for now. If you’re curious, read up on the Atomic Object blog, that’s a great writeup.

Back to primitive obsession. I think that Ruby developers are lucky but burdened by Rails, specifically when it comes to “good OO”. ActiveSupport is a rad library, and I fondly remember reading the Rails book in 2006 and being blown away by the ability to do 2.days.from_now.

One of the things I appreciate from Arel is that when you make a query you get back an instance of ActiveRecord_Relation not an Array. You can ask this relation questions you couldn’t, and shouldn’t, ask an Array. This brings me to something I don’t often see in Ruby… collection classes.

A collection class is a class that represents a collection of objects. Why might you use a collection class over an Array or a Hash, or even a Set? Most likely because you want to ask that collection questions that Array, Hash, and even Set have no idea about. We reach for these custom classes because a primitive is too simple, too basic, and we end up asking questions in the wrong places.

I had to interact with a remote API that did not give back good error messages. An example of how this works:

class WidgetCollection
  include Enumerable

  attr_accessor :errors

  def initialize(widgets)
    @widgets = Set.new(widgets)
  end

  def each
    return enum_for(:each) unless block_given?

    @widgets.each do |widget|
      yield widget
    end

    self
  end

  def invalid_widget_present?
    return false unless errors
    !!/some pattern that we hope works for a long time/.match(errors.to_s)
  end
end

class Widget
  def self.fetch
    api_results = Fetch.call
    WidgetCollection.new(api_results).tap do |widgets|
      widgets.errors = api_results.fault_code # a string, could be anything :(
    end
  end
end

# elsewhere...

widgets = Widget.fetch
log(a_message) if widgets.invalid_widget_present?

It’s unfortunate that the remote API gives us a fault code like that, but at least we can hide it in a class and keep our code a bit cleaner. Granted, there are more moving parts in our production code, but this way of dealing with the remote API feels like the right way. Much better than using an Array and checking the status further out. That’s certainly not “good” OO!

What would that code have looked like?

# elsewhere...

widgets = Widget.fetch
log(a_message) if WidgetCollection::ERROR_MESSAGE.match(widgets.errors)

That requires you to know way too much, and it’s a sign that you’re relying too heavily on primitives.

Respecting the boundaries is an important part of practicing object oriented programming. When you don’t create classes, especially for collections, you push responsibility out instead of pulling it in. This got a bit longer than I expected, so I’ll kick the actual production bug to a separate post.

Stay tuned!

So, I’ve decided to go native for a bit. 3 concerns:

Instant Message

Pidgin is king here, especially on Linux. While the buddy list is overpopulated with people I don’t chat with, or have never chatted with, it’s easy to clean it up. I need to learn the keyboard shortcuts, otherwise I think it’ll work out well.

The only thing I’d like to add is SMS support. I already use MightyText and luckily there is already a pidgin-mightytext plugin. Just need to compile it and get it set up. Hopefully it works.

Email

Gmail is fast and powerful. Evolution and Thunderbird are both too bloated and ugly for my tastes, so I’m left with Geary from the Yorba Foundation. I installed it via the daily PPA and easily set up my 2 email accounts.

sudo add-apt-repository ppa:yorba/daily-builds
sudo apt-get update
sudo apt-get install geary california

Calendar

Again, Evolution was too bloated and ugly, so I’m giving California a whirl. It’s fast, sleek, and has natural language parsing like the quick add in Google Calendar.

It was simple to get it set up with a normal Gmail app, but in order to get it working with my Google Apps acct for jc00ke.com I had to install Evolution. I got that tip from this bug report. The crux is to leave Evolution alone once set up. If you remove it, your Google Apps integration with California will also disappear. I’m sure it’ll get fixed soon.

Outro

So far I’m enjoying the speed and minimal system resources by switching to Pidgin, Geary and California. The native notifications have been missed too!

After a little digging I found this comment on the Ubuntu bug tracker and it helped sort out my preferences.

--- /usr/share/applications/defaults-old.list 2015-03-25 10:25:14.905796546 -0700
+++ /usr/share/applications/defaults.list 2015-03-25 10:27:02.195005915 -0700
@@ -271,6 +271,6 @@
 text/xml=firefox.desktop;google-chrome.desktop;google-chrome-unstable.desktop
 application/xhtml_xml=google-chrome.desktop;;google-chrome-unstable.desktop
 image/webp=google-chrome.desktop;;google-chrome-unstable.desktop
-x-scheme-handler/http=firefox.desktop;google-chrome.desktop;google-chrome-unstable.desktop
-x-scheme-handler/https=firefox.desktop;google-chrome.desktop;google-chrome-unstable.desktop
+x-scheme-handler/http=google-chrome-unstable.desktop;google-chrome.desktop;firefox.desktop
+x-scheme-handler/https=google-chrome-unstable.desktop;google-chrome.desktop;firefox.desktop
 x-scheme-handler/ftp=google-chrome.desktop;;google-chrome-unstable.desktop

--- /etc/gnome/defaults-old.list 2015-03-25 10:24:45.492371994 -0700
+++ /etc/gnome/defaults.list 2015-03-25 10:26:01.676061182 -0700
@@ -259,6 +259,6 @@
 x-content/image-picturecd=shotwell.desktop
 zz-application/zz-winassoc-xls=libreoffice-calc.desktop
 x-scheme-handler/apt=ubuntu-software-center.desktop
-x-scheme-handler/http=firefox.desktop
-x-scheme-handler/https=firefox.desktop
+x-scheme-handler/http=google-chrome-unstable.desktop
+x-scheme-handler/https=google-chrome-unstable.desktop
 x-scheme-handler/mailto=thunderbird.desktop

I also noticed that Firefox had taken over text/xml and that Chrome was set to open image/webp so I fixed those too. This is all a bit of a PITA, and counter-intuitive to how preferred apps should work. I should set them in one place and all apps should read from that source.

Anyway, hope this helps.

Update

Turns out Firefox kept hold of certain things, so I uninstalled it. Didn’t use it much anyway.

Apologies for the image, I could’t figure out how to embed just the relevant diff. Here’s the whole shebang.