Many thanks to DDD SouthWest organisers for a slot to share my experience as garage quant. This is the sides I used on the talk.

• https://docs.google.com/presentation/d/1hxFPS0zHNGQ3zIW5Imaz_3zj-LWLCEYEOEulozYfXP0/edit?usp=sharing

Tenant is a term that describes the country the application runs in at Just Eat. For example, UK, IE (Ireland) are two different tenants. I’ve created an api that accepts a scheduled event. The endpoint is like this

POST api/v1/uk/events

At the moment, we’ll only support 7 different tenants. The api should return BadRequest if the country code doesn’t fall on those 7. It fits well for ASP.NET Core Middleware, middleware gets executed on every request.

What’s middleware? Middleware is software that’s assembled into an application pipeline to handle requests and responses

For implementation, I need to do

1. Create an extension method, app.UseRequireTenantValidation() to hook up the middleware
2. Write the middleware
3. Use the middleware in Startup class

1. Extension method

public static class ValidateTenantOnRequestExtensions
{
    public static IApplicationBuilder UseValidateTenantOnRequest(
      this IApplicationBuilder builder)
    {
        return builder.UseMiddleware();
    }
}

2. middleware

public class ValidateTenantOnRequestMiddleware
{
    private readonly RequestDelegate _next;

    public ValidateTenantOnRequestMiddleware(
      RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        if (context.GetRouteData().Values.ContainsKey("tenant"))
        {
            var tenantStr = context.GetRouteValue("tenant") 
              as string;
            Tenant _;
            var success = Enum.TryParse(tenantStr, true, out _);
            if (!success)
            {
                context.Response.StatusCode = 
                  (int) HttpStatusCode.BadRequest;
                await context.Response.WriteAsync(
                  new Error(new UnsupportedTenantException(tenantStr)).Message);
            }
        }

        await _next(context);
    }
}

However, it turned out that global filter has better support in terms of routing. app.AddMVC() populate route data and it happens almost at the latest on the pipeline. So, GetRouteData() at the middleware level returns null. Ok. I learn while I go. Let’s change the code to filter.

TenantFilter

public class TenantRequiredFilterAttribute : Attribute, IResourceFilter
{
    public void OnResourceExecuting(ResourceExecutingContext context)
    {
        if (context.RouteData.Values.ContainsKey("tenant"))
        {
            var tenantStr = context.RouteData.Values["tenant"] 
              as string;
            Tenant _;
            var success = Enum.TryParse(tenantStr, true, out _);
            if (!success)
            {
                context.Result = new ObjectResult( 
                  new Error(new UnsupportedTenantException(tenantStr)))
                {
                    StatusCode = 400
                };
            }
        }
    }

    public void OnResourceExecuted(ResourceExecutedContext context)
    {
    }
}

The code is almost the same, except that now the clas inherits IResourceFilter.
You can add the filter to the pipeline in Startup.

services.AddMvc(options => { 
    options.Filters.Add(); });

My partner works as acupuncturist. As self-employed person, she’s got a website, and recently, the hosting company was bought out, leaving her website down. I’ve moved her website to Amazon S3. Everything worked well, except her contact email address, info@hyeeun-acupuncture.co.uk.

SES is not supported on London Region, I chose Ireland, EU-WEST-1.

Create a rule.

1. Add recipient. info@hyeeun-acupuncture.co.uk
2. In Actions, first choose S3 and select the bucket you want to store the email
   1. I’ve created directory inside the bucket, “emails”. Put emails as Object key prefix
3. In the next page, I’ve put info-rule as rule name. Then clicked on “Create Rule”.

I got an error, “Could not write to bucket: xxxx-xxxx-email” It’s because I didn’t set the policy in S3 bucket to allow SES access. I followed a very helpful instruction from https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-permissions.html. You need to know your account Id

Now, let’s send an email to test if the mail goes into the S3 bucket.

5 minutes later, the email still didn’t appear. What did I do wrong? I’m reading SES instruction again.

Interestingly, 10 minutes later, I’ve got an email from Amazon, saying “Please note that the rule that you configured to deliver emails to this S3 bucket is only valid if the entire setup process is successful. …” Hmm, what does it mean by “entire setup process”?

1. Verify your domain: O
2. Configure in Route 53: O
3. Set S3 bucket name: O
4. Set Object Key Prefix: X.

Ah I’ve missed setting the folder name as Object Key Prefix. I was setting it and writing about it at the same time. Also my colleagues were chatting loudly behind me, so I must have been distracted.

After a few more failed retries, I finally set it up successfully. The cause for the failure was that I didn’t put the name on Route 53 record set correctly. The name should be the same as the domain. In my case, the name should have been “hyeeun-acupuncture.co.uk.” Before it was “info-hyeeun-acupuncture.co.uk.”

Lambda …

I’ve created a lambda function, but failed to set it on SES rule set. It seems SES doesn’t have enough permission to access the function.

After while … It turned out that I had SES on eu-west-1 and my lambda was on eu-west-2. SES rule set wasn’t able to show the lambda function. So I’ve created a function eu-west-1. It enabled me to select the function on rule set and AWS console kindly added the right permission to the lambda.

It all works now. To summarise the steps I went through

1. Create a lambda with ses-forwarder.
2. Verify domain on SES. Create MX record on Route 53
3. Verify your email address on SES
4. Create a rule set that SES receives emails to your domain. The rule set will have actions, 1) S3 and 2) Lambda
5. Test

Resources

• https://bravokeyl.com/how-to-set-up-email-forwarding-with-amazon-ses/
• https://github.com/arithmetric/aws-lambda-ses-forwarder
• SES overview: https://docs.aws.amazon.com/ses/latest/DeveloperGuide/getting-started.html
• SES Email Receiving: https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-setting-up.html

“Read your programming book as normal. When you get to a code sample, read it over

Then close the book.

Then try to type it up.”

from http://www.pathsensitive.com/2018/01/the-benjamin-franklin-method-of-reading.html

Functional programming can make your head explode. This book stitches it back together.

Daniel Marbach, Particular Software

All the code examples are on Github, https://github.com/la-yumba/functional-csharp-code

The author is very good at explaining the definitions of functional concepts and jargons. Especially I liked his way of introducing functor and monad with maps and bind.

Enrico Buonanno’s online presense:

• https://twitter.com/la_yumba?lang=en
• https://medium.com/@enrico.buonanno

JavaScript has grown massively recently with the introduction of Node.js, and it serves as a language for Front-End, Server-side api, desktop app, and even for mobile app. It’s a kind of universal language every platform understands.

So, it’s no wonder that you build command-line tools with node.js. Recently, at Just-Eat, I had to upload a custom ZenDesk app via ZenDesk api and wanted to build a script that would do the job. So my choice was node.js with command.js.

Packages you need

• command.js
• inquirer.js
• request.js

With command.js, you can build command-line arguments in a very clear way.

const program = require('commander');
const request = require('request');
const fs = require('fs');

console.log('ex) node zen i <subdomain> <token>\n');

program
  .version('0.0.1')
  .description('ZenDial Installer');

program
  .command('install <subdomain> <token>')
  .alias('i')
  .description('to install ZenDial')
  .action((subdomain, token) => {
    install({subdomain, token});
  });

One tricky bit was to add basic authentication with formData. I’ve spend 20-30 minutes to figure it out. It turned out that I had to specify the endpoint url in {} object.

const install = (params) => {
  console.log(params);

  const user = 'user@email.com';
  const password = params.token;
  const fileStream = fs.createReadStream('ZenDial.zip');

  console.log('uploading the file...')

  request.post({
    url: 'https://' + params.subdomain + '.zendesk.com/api/v2/apps/uploads.json',
    formData: { uploaded_data: fileStream },
    auth: { 'username': user, 'password': password }
  }, function(err, res, body) {
    if (err) {
      console.error('upload failed:', err);
      return;
    }

    console.log('file uploaded')
    console.log(body);

    const uploadId = JSON.parse(body).id;
    console.log('upload id: ' + uploadId)

    request.post({
      url: 'https://' + params.subdomain + '.zendesk.com/api/v2/apps.json',
      form: {
        name: 'Zendial v2',
        short_description: 'Zendesk-to-liveops integration app',
        upload_id: uploadId
      },
      json: true,
      auth: { 'username': user, 'password': password }
    }, function (err, res, body) {
        if (err) console.log(err);

        console.log(body);
    });
  });

}

program.parse(process.argv);

I’m on call this week, and whenever there’s alert, it comes to my mobile. I’ve had Error rate > 5% alert from PagerDuty the other day. I’ve acknowledged the alert, (otherwise it keeps sending me the alerts) and investigated it.

A public action method ‘Login’ was not found on controller ‘xxxxWeb.Controllers.HomeController’

It was interesting. The action method definitely exists there, but we had 5 errors instantly. After investigation and some googling, it turned out that excel spreadsheet and some crawling bot were hitting the endpoint with HEAD and OPTIONS verb.

Why? I don’t know, but the fix was simple. Currently, Login was constrained to GET. Simply take off the constraint and the page will serve HEAD and OPTIONS very well.

It’s fun to be a on-call engineer. You can see loads of things you haven’t expected to see, in real world, on production server.