I’ve never done Java full-time, and while I know the basics of the language – I even got a “Sun Certified Java Programmer 1.4” certification back in the day, just for kicks – I hadn’t explored the newer features like Generics, Annotations and whatever else. So with that in mind I fired up IDEA and started playing around.

I soon ran into some troubles though!

When I switched my project to point at the 1.7 JDK, IDEA was telling me:

java: System Java Compiler was not found in classpath

A Stackoverflow post suggested using the “Eclipse” compiler instead of “Javac”, and this seemed to do the trick, but I didn’t know why so that wasn’t ideal. I checked my JAVA_HOME variable and all was good:

/Library/Java/JavaVirtualMachines/jdk1.7.0_51.jdk/Contents/Home

Running javac -version from the command line gave me the right version too:

javac 1.7.0_51

So no idea why Javac mode wasn’t working, but I went back to playing around.

Soon after I wanted to check out Junit, so followed the instructions to add that to my project using Maven (now I have two problems!). I’m new to Maven as well, so I was relatively blindly just adding the JUnit dependency and using IDEA to sort the rest out for me and hoping for the best.

The problem now I was that I couldn’t compile using maven. It was giving me an unsual error:

class file has wrong version 51.0, should be 49.0

… and this error was in reference to java.util.List!

I tried compiling from the command line using javac and got an error illegal start of type where I was using the Java 1.7 “diamond” notation:

1

List<String> strings = new ArrayList<>();

javac -version and my JAVA_HOME were definitely pointing to the 1.7 JDK so I was very confused. After some additional research, I tried doing:

javac -source 1.7 -target 1.7 Foo.java

but kept getting errors like: invalid source release: 1.7 – which were very perplexing! -target 1.6 didn’t work either, but -target 1.5 did, which was very strange.

A bunch of Google searches for these various errors I’d been having yielded no useful answers for my situation – basically most of them boiled down to invalid JAVA_HOME settings, but mine were fine!

So to cut a long story short, and it’s already been spoiled if you’ve read the title, there’s a /Library/Java/Extensions directory on Mac OS X that contains additional JAR files that are on the default classpath. These JARs can be installed by other applications, and can cause conflicts with other JARs you’re expecting. I removed all the JARs from this folder and suddenly everything worked fine! IDEA could compile in Javac mode! Maven compiled! javac from the command line compiled!

I suspect the culprit was the tools.jar that had been placed there by something. This tools.jar was, I assume, from the Java 1.5 JDK. tools.jar appears to contain the classes for the Java Compiler, amongst other things. So despite the command line compiler being from 1.7, the actual classes that it was loading to do the compilation were from Java 1.5!

It took me two hours or so of futile searching, experimentation, reinstalling of JDKs, etc, before I finally remembered that I’d been bitten by /Library/Java/Extensions before. Should’ve thought of it sooner!

Anyway, this post probably won’t be useful unless you’re in this particular situation, but my hope is that by adding all those error messages in the post and the solution, somebody else who runs into the same issue will find my post instead of wasting time trying to work it out!

The slides by themselves probably aren’t the most useful, and if you want to learn about Koa you might just be better off reading the docs!

Koa presentation slides

I’ve been putting in a bit of time during the holiday break, in between baby wrangling and Christmas duties, and have managed to add a bunch of useful features to the CFML CI template.

Multi-platform support

The biggest change is that the scripts now support running Adobe Coldfusion 9.0.2 and 10. In addition, with the changes made to support multiple platforms, Railo 4.0 and the new 4.2 beta have been added to the default list of platforms – although for Railo this was trivial, just point at different archives.

ACF support was a bit trickier, as ACF requires an “installation” before it’ll run. I have done this install step, gone through the initial setup screens, applied patches, and packaged up the result. I am hosting these pre-installed re-packaged version on an S3 bucket, and downloads from Travis CI are pretty darn fast (they might be on AWS infrastructure as well). The other part of the puzzle was doing a find and replace from the original installed path to wherever it had been installed by the CI scripts. Oh yeah, and just for good measure the startup script was tweaked to remove the requirement to run as root!

The good thing was the work to get ACF10 working translated pretty easily to ACF9 – with minor differences for paths and startup procedure for the server. Future versions of ACF should also be able to be supported, although supporting the future versions may be easier from what I’ve seen in the pre-release program.

Adobe ColdFusion and multi-platform support is on the master branch of the CFML CI project:

https://github.com/marcins/cfml-ci

These changes have also been backported and merged into FW/1 – it’s test suite is now running against the main supported versions:

https://travis-ci.org/framework-one/fw1

TestBox

Initial experimental support for TestBox has also now been added, however I am waiting for the 1.0.1 release before it ends up on master as currently the build doesn’t fail if there are test errors, there is a fix coming that allows for writing out a properties file that can be used to determine whether the tests failed. You can see the test matrix for this branch on Travis CI:

https://travis-ci.org/marcins/cfml-ci

(Although technically those TestBox tests should be failing as there’s an intentional failure in there)

TODO

The only thing remaining for this iteration is to update the documentation to cover multiple test frameworks, and update the Jenkins documentation to describe how to set up a multi-config / “matrix” project to allow for testing the various platforms from a single project.

https://github.com/marcins/cfml-ci

The README contains instructions for integrating with your CFML project.

What’s Continous Integration?

Stepping back a bit, you may be wondering what Continous Integration (CI) actually is. Roughly speaking, it’s the idea that your tests / build process is run continously, automatically, whenever a change is made to the repository – giving you immediate feedback if the changes are going to break the build.

Travis CI

Travis CI is a CI Software as a Service (SaaS) platform, originally started for the open source community. It provides a number of different language environments for running tests in – including Java. Travis CI is free to use for open source projects (but your builds are public), and integrates closely with Github. What this means is that when a FW/1 Pull Request is opened now, it will automatically have the tests run by Travis, and the results will be shown in Github – giving you plenty of warning before you merge a “broken build”.

It also provides you a nice image you can stick in your Github README (or anywhere else) with the current status of the build, for example this is the live status of the CFML CI project:

The process

There were a few modifications required to a few components in order to get everything working smoothly:

• A patch was required to MXUnit as on a default Railo install it tries to output some null properties in the XML output which was causing a failure.
• Modifications were required to the Ant Runner CFC as some of the FW/1 tests set the status code to 500 (error) which flowed through to the test output causing a failure
• A custom output Ant task was written that takes the output from the test runner and displays it on the Ant console, otherwise on Travis CI if the tests failed you would not get any feedback as to which test had failed in the console.

The scripts currently only work with Railo, because Adobe does not provide an equivalent to Railo Express which makes a simple download / extract / run process impossible on ACF. Need to experiment with the idea of installing and configuring ACF locally and creating a “ready to run” package.

The future

There’s still a bit of work I’d like to put into this, some of it a bit simpler than others:

• support for multiple versions of Railo, and Adobe ColdFusion
• create a new version of the MXUnit Ant task that integrates the console output as well as fixing some other minor issues
• there’s already brief guides for running on Travis and Jenkins, but provide documentation for integrating with other CI servers (Bamboo, ??)
• make it work on Windows (it’s very unix dependent right now – would probably involve rewriting the helper script in something more portable) – although this isn’t a high priority for me

As always with open source, feel free to contribute your code or comments via the Github repo!

Resource Routes

Resource Routes were contributed by John Berquist for FW/1 2.2. This is actually something I had also proposed a long time ago, I mentioned it in my CF.Objective(ANZ) presentation this time last year, but never got around to implementing. So thanks, John!

Resource Routes allow you to simplify adding REST style routes to your route table. In my presentation I showed a set of routes required to implement a RESTful API for a resource, basically Resource Routes allows you to replace those with a single entry using the magic $RESOURCES route.

renderData

The other cool feature is a renderData function that simplifies the process of returning non-HTML content from a FW/1 controller. Currently returning data in JSON, XML and text is supported. There have been a couple of ways of doing this in the past, using an onMissingView function in Application.cfc or using a special view that would set the content type. renderData makes this a one-liner without any additonal requirements.

Building a REST API

By combining renderData and Resource Routes it makes it easier than ever to build a REST style API with FW/1. I’ve created a simple example project that implements, of course, a TODO list application. It’s not necessarily best practice, but I think it shows how easy it is to provide an API and cosume it. For a “real” app for the front-end code I’d probably use something like Backbone or AngularJS instead, but in the interests of keeping the barrier to understanding the code low I’ve kept it as plain JS (with jQuery).

https://github.com/marcins/fw1-rest-example

RESTful routes

This is grossly simplifying the topic, but essentially the idea of REST is that URLs point to particular resources in your data model, and the HTTP method determines what to do with that resoruce (eg. GET to get data, POST to create a new object, PUT to update, DELETE to delete). There is also the concept of child objects, so for example in the TODO app a list item is referenced through it’s list:

/lists/LISTID/items/ITEMID

The routes in Application.cfc to support this are quite simple:

1
2
3

routes = [{
  "$RESOURCES" = { resources = "lists", nested = "items" }
}]

This requires two controllers, lists and items, and with the default settings will create routes for the following actions in the controller:

• default (GET without id)
• show (GET with id)
• create (POST)
• update (PUT)
• destroy (DELETE)

For these methods rc will have available, where relevant, lists_id and items_id (in the items controller).

You can configure which methods are available, and a whole bunch of other stuff, in the route as well. The FW/1 manual goes into detail as to what configuration options are available.

Error handling

The easiest way to “throw” an error back to the Javascript is to use a HTTP response code. renderData allows this with an optional status code parameter, for example:

1
2
3
4

var list = getObjectStore().getObjectById(rc.lists_id);
if (isNull(list)) {
  return fw.renderData("json", {error = "List not found"}, 404);
}

Note that the example JS code doesn’t really handle these errors, mainly because I was lacking spare time and wanted to get this post out.

Accessing through Javascript

If you’re using jQuery there’s not really anything special you have to do here, if your actions are returning JSON using renderData("json", ...) then jQuery’s “intelligent Guess” for datatype will know it’s JSON and de-serialize it. The only trickiness is that there are only AJAX helper methods (eg. $.get) for GET and POST, not PUT and DELETE, so if you want to use those you’ll need to use the slightly more verbose $.ajax instead:

1
2
3
4
5
6
7

$.ajax(Example.baseUrl + '/lists/' + selectedList.id + '/items/' + itemId, {
  type: "PUT",
  data: {complete: !selectedList.items[itemId].complete}
}).done(function (data) {
  selectedList.items[itemId] = data;
  renderList();
});

I think it’s only IE6 and lower that doesn’t support anything but GET/POST from an XMLHttpRequest, so you should be OK in most cases.

Other points of interest

• the Javascript isn’t super efficient and will re-render the list of lists and list items when anything changes to keep the data in sync.

• there is no security or authentication – again, keeping it simple, but don’t do this in production :)

• the sample project includes a basic persistent object store to avoid the need for a database. This is definitely NOT for production use, but seemed like a useful thing to have for demos and works like a mini-Couch or MongoDB sort of thing.

After attending JSConf EU in September I just feel that there’s too much new stuff coming in JavaScript that clashes with what’s already in CoffeeScript that it might be better to stick to pure JS. Of course CoffeeScript generated JS won’t stop working, but it just sometimes feels like the little bit of nicer syntax isn’t worth the overheads to the process.

So my presentation was very wary in trying to advocate / evangelise CoffeeScript, it was more a case of “Hey, this is what CoffeeScript is and what it looks like. You might want to give it a go, but really be aware of the downsides”!

I’ve put the Introduction to CoffeeScript presentation online – there’s a live CoffeeScript code editor and compiler built into the slides, which was a bit of fun to write.

As for the conference itself, it was a lot of fun! Michael Hnat and the rest of the organising team did a great job, and the venue was excellent. Also loved the drinks on every table in the presentation rooms, and the copious amounts of pretzels for snacks. I met some interesting people, and saw some interesting presentations. It was only good timing with my family holiday that I could make it there this year, which is a shame as I’d happily come back next year if it wasn’t half way around the world.

For the impatient, here’s the CF Google Authenticator Github repo.

So for the details: These 2 standards are involved in the Google Authenticator implementation:

• RFC-6238 TOTP: Time-Based One-Time Password Algorithm
• RFC-4226 HOTP: An HMAC-Based One-Time Password Algorithm

The first is actually a specific implementation of the second, and what Google Authenticator tokens are based on.

HOTP is conceptually simple – you take the HMAC-SHA-1 of a shared secret key, and a counter. You then do some bit twiddling with the resulting 160-bit (20 byte) hash to get it down to a 4-byte number, from which you then extract a 6-digit number which is your token.

TOTP is a particular implementation of HOTP, where the counter is based on the number of seconds since the UNIX Epoch. Specifically it’s how many X second periods have there been since the epoch, where X is 30 seconds in Google’s case. This is why the number changes every 30 seconds.

So anyway, the actual derivation of the current token value from the secret is only a few lines of code, but there was some additional complexity to implementing this in ColdFusion.

Base32

The Secret Key that is required for the Google Authenticator app is encoded in Base32. This is a less common relation of Base64, but it’s a lot easier to type in manually as it only includes uppercase letters and numbers. Base32 is defined in RFC-4648 The Base16, Base32, and Base64 Data Encodings.

There is a Java based Base32 implementation in Apache Commons Codec, however it was only added in v1.5. Adobe ColdFusion 10 bundles Apache Commons Codec, but unforutnately it’s only v1.3. So if I wanted to use the library I’d have to include it and use a JavaLoader. In fact my first implementation did this, but I deicded to go for the extra challenge of implementing Base32 myself.

Java Crypto

This code also makes heavy use of Java Crypto, and so needs to put stuff into byte arrays and other native Java types. In retrospect the whole project might’ve been better implemented as a Java library that could just be loaded, in fact there probably already is one. However I treated this as more of a learning exercise, and challenged myself to do it entirely in native CF. It’s definitely easier to implement being a single CFC without any dependencies on external JARs.

QR Codes

The Google Authenticator app allows you to add your account by scanning a QR Code. I wanted to do this for my Proof of Concept / Demo, and it turns out there’s a neat little Javascript library for doing it called (funnily enough) qrcode.js. It’s got wide browser support by using canvas where available, and HTML tables where it’s not.

ColdFusion quirks

ColdFusion isn’t really designed for bit twiddling – even in cfscript there aren’t the usual bitwise operators and shifts, you have to use functions. There’s also no hex constants, so you need to convert stuff to decimal. Still, I guess CF isn’t really a general purpose language but web specific, so the demand for these types of operations is probably fairly low.

An example, it means you tend to be a bit more verbose:

1
2
3
4

byte = bitSHLN(bitAnd(this.DECODE_TABLE[encodedBytes[i + 4]], 1), 7);
byte2 = bitSHLN(this.DECODE_TABLE[encodedBytes[i + 5]], 2);
byte3 = bitSHRN(this.DECODE_TABLE[encodedBytes[i + 6]], 3);
decodedBytes.write(bitOr(bitOr(byte, byte2), byte3));

instead of being able to do the more typical:

1
2
3
4

decodedBytes.write(
    (this.DECODE_TABLE[encodedBytes[i + 4]] & 0x1) << 7 |
    (this.DECODE_TABLE[encodedBytes[i + 5]] << 2) |
    (this.DECODE_TABLE[encodedBytes[i + 6]] >> 3));

There was also a fair bit of casting, and using Java classes in order to get things into (mainly) native byte[] arrays.

As I said though, as a learning exercise it was definitely interesting to explore some of the lesser used parts of CF, and refresh my bitwise operator math. There was even a piece of paper and pen involved in working some of it out!

Monit isn’t installed on the instance by default so we’ll need to install the package. After that we just need to configure it to monitor delayed_job and make sure it’s running. This is actually pretty simple with just the standard .config files.

Here is my .ebextensions/90monit.config:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

packages:
  yum:
    monit: []
files:
  "/etc/monit.d/delayed_job":
    mode: "000644"
    owner: root
    group: root
    content: |
      set mailserver smtp.gmail.com port 587
      username "system@XXXXXX" password "XXXXXX" using tlsv1
      with timeout 30 seconds

      set httpd port 2812 and
        use address localhost  # only accept connection from localhost
        allow localhost        # allow localhost to connect to the server and

      check process delayed_job
        with pidfile /var/app/support/pids/delayed_job.pid every 2 cycles
        start program = "/usr/bin/env BUNDLE_WITHOUT=test:development RAILS_ENV=production /var/app/current/script/delayed_job --pid-dir=/var/app/support/pids start" as uid webapp and gid webapp
        stop program = "/usr/bin/env BUNDLE_WITHOUT=test:development RAILS_ENV=production /var/app/current/script/delayed_job --pid-dir=/var/app/support/pids stop" as uid webapp and gid webapp

      alert alerts@XXXXX with mail-format {
        from: system@XXXXXX
        reply-to: alerts@XXXXXX
        subject: XXXXXX $SERVICE $EVENT at $DATE
      }
commands:
  remove_bak:
    command: "rm /etc/monit.d/delayed_job.bak"
    ignoreErrors: true
service:
  sysvinit:
    monit:
      ensureRunning: true
      enabled: true

Basically what we’re doing is:

• Using yum to install the monit package
• deploying a config file for monitoring delayed_job into /etc/monit.d (more on this later)
• When you deploy the config script, if it already exists Elastic Beanstalk will create a backup. We need to delete this file if it exists because monit will load all files in /etc/monit.d regardless of extension
• ensure the monit service is enabled and running

So the config file for monit is where the interesting stuff is. We’re configuring stuff in here that we’d probably normally put in core monit config, but in the interests of keeping the deployment script simple we do it all from one script.

What we’re doing with this config is:

• Setup our mailserver to use GMail SMTP to send the emails – I’m using a specific service account.
• Setup the monit httpd service so we can run monit status on the instance when debugging
• Setup the config for monitoring delayed_job – more on this below.
• Last of all we setup an alert to be sent to our alerts email when there’s a status change for delayed_job

So the hardest part was getting the commands right. There were a few pages I found that gave me most of the answer, however not fully – for me it was failing for ages because I didn’t have the BUNDLE_WITHOUT variable set when trying to run the script and I have some test specific dependencies.

The part that makes this more difficult is because monit runs your commands with an extremely cut down shell – all you get is basically the path, with no other environment variables. So what we’re doing is running our command through /usr/bin/env to setup the environment (although I’m not sure that’s actually doing anything), and explicitly passing the RAILS_ENV. We also need to specify the user to run the commands as, otherwise the delayed_job service will start up as root – which is not good.

I could probably improve this script by refactoring the commands to use the Elastic Beanstalk environment like $EB_CONFIG_APP_CURRENT rather than hardcoding /var/app/current, but it’s working for now so I’ve left it alone – and as I said above, monit runs commands in a very cut down environment so getting those variables in might not be easy.

Anyway, that’s another piece of my Elastic Beanstalk puzzle. Pretty simple in hindsight, but probably took a good hour or two of fiddling around on the instance, trying various approaches, reading documentation and so on to finally get it all working reliably and repeatably.

Recently I’ve been helping out a friend with a website and we are deploying it to AWS via their Elastic Beanstalk service. I’ve learned a few quirks of the platform in my, albeit brief, time working with it. One of these is that there’s no official way to run a “post deploy” script. You can run “Container Commands”), which are executed in your application directory BEFORE it is deployed (ie. made live), but no way to run a script AFTER your application is deployed (ie. when your application is in /var/app/current and the web server has been restarted).

Why would you need to do this?

Well, in my case I am using delayed_job as a worker for this Ruby on Rails app, and need to restart delayed_job when the application is deployed. I can’t do this before the app is live, because at that point the app is still in /var/app/ondeck and this seemed to cause problems. Also at this point the deploy could still technically fail, and you’d be left with the “old” version of the application running, but with the “new” delayed_job instance. Not good.

So when I was looking at the eb-tools.log on the EC2 instance I found it was searching for scripts to run in a /opt/elasticbeanstalk/hooks/appdeploy/post directory after restarting the web server. Turns out if you drop shell scripts into this directory they will be executed post deployment, just like you want! However this directory does not exist by default, as Amazon does not use any post-deploy scripts, so we also need to make sure this directory is created.

You can use the regular config YAML files that go in your .ebextensions folder in order to deploy a shell script that will be run after the deployment is complete.

This is my 99delayed_job.config:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

commands:
  create_post_dir:
    command: "mkdir /opt/elasticbeanstalk/hooks/appdeploy/post"
    ignoreErrors: true
files:
  "/opt/elasticbeanstalk/hooks/appdeploy/post/99_restart_delayed_job.sh":
    mode: "000755"
    owner: root
    group: root
    content: |
      #!/usr/bin/env bash
      . /opt/elasticbeanstalk/support/envvars
      cd $EB_CONFIG_APP_CURRENT
      su -c "RAILS_ENV=production script/delayed_job --pid-dir=$EB_CONFIG_APP_SUPPORT/pids restart" $EB_CONFIG_APP_USER

What this config does is:

• create the “post” directory if it doesn’t already exist (it won’t by default) – ignore any errors (such as if the directory already existed)
• deploy the shell script with the appropriate permissions into the right directory

What the shell script does is:

• setup the environment variables (I borrowed this line from the other shell scripts in /opt/elasticbeanstalk)
• change to the “current” directory – this will probably be /var/app/current but we don’t make any assumptions
• restart delayed_job as the app user (usually webapp), using a shared pids directory to make sure it kills the old version first

So after commiting the config file and doing a git aws.push you should see something like this in your /var/log/eb-tools.log:

2013-05-16 01:20:53,759 [INFO] (6467 MainThread) [directoryHooksExecutor.py-29] [root directoryHooksExecutor info] Executing directory: /opt/elasticbeanstalk/hooks/appdeploy/post/
2013-05-16 01:20:53,760 [INFO] (6467 MainThread) [directoryHooksExecutor.py-29] [root directoryHooksExecutor info] Executing script: /opt/elasticbeanstalk/hooks/appdeploy/post/99_restart_delayed_job.sh
2013-05-16 01:21:02,619 [INFO] (6467 MainThread) [directoryHooksExecutor.py-29] [root directoryHooksExecutor info] Output from script: delayed_job: trying to stop process with pid 6139...
delayed_job: process with pid 6139 successfully stopped.
2013-05-16 01:21:02,620 [INFO] (6467 MainThread) [directoryHooksExecutor.py-29] [root directoryHooksExecutor info] Script succeeded.

As I said, putting stuff in this “post” directory is undocumented – but hopefully at some point Amazon add actual support to the .config scripts to run commands post-deploy, in that case you could just move the restart comamnd itself to the officially supported approach.

However I ran into issues when trying to get CIDetector to find faces in the CIImage from the video.  Eventually I came across the Apple SquareCam sample which contained the solution!

The reference for CIDetector only mentions the - featuresInImage:(CIImage *) selector, however there is also an - featuresInImage:(CIImage *) options:(NSDicitonary *) selector which can be used to provide a CIDetectorImageOrientation key.  This is documented in the CIDetector.h (and appears to only be available on iOS and not Mac).  The iPhone camera actually captures video “natively” in landscape mode, so if you’re holding the camera in portrait you need to tell the detector this (I’m sure if I was more familiar with the AV Foundation framework this would have been obvious).

The SquareCam sample has a good chunk of code for converting a UIDeviceOrientation to the CIDetectorImageOrientation required by CIDetector (essentially an EXIF orientation) - this includes an enum for the various EXIF orientations and working correctly for the front and rear facing cameras, but as a basic hack for working in portrait mode with the front facing camera all you need to do is:

1
2
3

imageOptions = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:6]
forKey:CIDetectorImageOrientation];
NSArray *features = [detector featuresInImage:image options:imageOptions];

(this is the 0 row on the right and 0 col on top orientation - ie. image needs to be rotated 90º CCW to get it to the right orientation)

Anyway, probably something obvious for more experienced folk, but having never played with the AV stuff I didn’t realise what the issue could be, so was happy to find the solution, so I’ll leave this here in case anyone else is running into the same issue.

If you are suffering from a so-called “login loop” in Mac OS X 10.7 Lion - ie. you login to your account and then suddenly you’re back at the login prompt again - your LaunchServices cache might be corrupt.

If you check your Console from another user account and the Stack Trace for a bunch of login related processes (loginwindow etc) shows a crash in:

0   com.apple.LaunchServices       0x00007fff8fa7dd24 CSStoreGetUnit + 40

Then this may be the case.  Older articles around the internets refer to deleting the LaunchServices cache in /Library/Caches or ~/Library/Caches however on my Lion machine I couldn’t find this file.

Where you’ll actually find it is in:

/private/var/folders/XX/YY/C/com.apple.LaunchServices-034ZZZ.csstore

Where XX and YY are random names - your user account will only have access to your own, you’ll need to look into each of the folders under “folders” and find which one is yours (ls -al will show ownership).

The ZZZ is your userid (a number - the first user on the machine is 501 and so on).

Delete this file and you should be able to login! 

Note that this cache stores all of your customised file associations and things like default browser - so you’ll lose those settings. It might even lose your “Login Items” you’ve configured, but I can’t be sure that wasn’t one of the other files I’d previously deleted that stored that :)

Took me about 3 hours of mucking around and searching for clues on the Internet to find that bugger!