Published June 25, 2019

Broken CircleCI Builds and Particle Mesh

Display broken CircleCI builds with a Particle Mesh IoT network.

IntermediateFull instructions provided1 hour682

Broken CircleCI Builds and Particle Mesh

Things used in this project

Hardware components

Particle Argon

Particle Xenon

adafruit 1.2" 7-segment LCD HT16K33 Backpack

Adafruit 4-in-1 Display Dot Matrix Module (16×8) – MAX7219 Microcontroller

Software apps and online services

Now — Global Serverless Deployments

CircleCI

Story

This project piggybacks on my last article Creating an IoT Scrolling Marquee with Slack and Particle.

Instead of a scrolling marquee displaying unique messages, I wanted to only receive notifications when a continuous integration platform failed a build. Things that would be helpful in this notification would be, what branch failed and who was the user.

CircleCI is a great continuous integration platform that I use a lot for personal projects, however I sure this approach (or similar) will work with most.

The CircleCI config.yml allows you to call a command on "Build Failed". This is great, because we can cURL a POST request to an API passing it our CIRCLE_BRANCH and CIRCLE_USERNAME. Easy!

Once additional spin on my approach with this project is that I wanted to use Particle Mesh Networking. Essentially, a Particle mesh network consists of a gateway device with network access, and one/may endpoint devices. A much better explanation can be found here on the Particle blog.

My example is going to use the Argon WiFi gateway device and 2 x Xenon endpoint devices.

Gateway and endpoint devices can communicate with each other by publishing or subscribing to events. Only devices on this network will have access to these events.

Knowing this, we can define a function on our gateway device (Argon) display_broken_build, which when called by the API, can then emit a custom event on our network matrix_display_message. Our endpoints, which will be subscribing to the event matrix_display_message, can then perform a specific action.

My plan is to have 1 Xenon endpoint operate a scrolling marquee, while the other Xenon endpoint displays a tally of the amount of broken builds. What this showcases is that in a workplace environment, we could have multiple devices on our network displaying notifications of broken builds and perhaps more detailed statistics.

CircleCI

First we need a build that will fail. Create a git repo and create a .circleci/config.yml file. (see example)Make sure you then select your git repo in the CircleCI app.Also create a package.json file in your new repo.
This manifest will have no dependencies or scripts. (see example)

my-failing-repo
 | - .circleci/config.yml 
 | - package.json

Pushing this to github with cause CircleCI to build your project.

First it will install npm dependencies, and then npm foo which shouldn't existing in your package.json file, resulting in a failed build.

API

I've created a expressJS API (index.js) with a single route /display.

On /api/display the API will log into my device and call it's display_broken_build function, passing it the branch and user values.

The API references environment variables stored in a local.env file.

PDEVICE=particle_device_id
PUSER=particle_user
PPASS=particle_password

The API is then hosted on now and my now.json manifest exposes my route and secrets to the API.

You can provide your secrets to your now deployment like so:

now secret add mesh-pub-user foo@bar.com

Once the API has deployed, update the reference to the endpoint in your .circleci/config.yml file.

Argon (Gateway)

I’m using the Argon as my gateway device.

Using Particles’ Workbench, I flashed the argon-publish.ino on my device.

You'll notice on setup I define the function display_broken_build that accepts a command (string), and on the event that function is called via the API, I call a displayMessage function, which will then emit matrix_display_message out onto the network.

Xenon - Scrolling Marquee (Endpoint)

The code for this device (xenon-subscribe-scrolling-marquee.ino) is very similar to my original scrolling marquee example.

The difference being that on setup this device subscribes to a matrix_display_message event. Once received, call displayMessage, resulting in writing to the LCD.

Mesh.subscribe("matrix_display_message", displayMessage);

Xenon - Counter (Endpoint)

The code for this device (xenon-subscribe-counter.ino) is pretty simple.

I initialise a count of 0, and every time matrix_display_message is published it calls logToDisplay, incrementing the count by one and sending it to the LCD display.

Conclusion

Once the API was deployed, devices flashed, and failing CircleCI repo published, I had my own sweet IoT network of displays notifying me when a build had failed.

Display broken CircleCI builds using a Particle Mesh Network

Code

/// This #include statement was automatically added by the Particle IDE.
#include <ledmatrix-max7219-max7221.h>

LEDMatrix *led;

String message = "";
int speakerPin = D3;
int bitmapWidth = 32;
int webcount = 60001;
int iterationCount = 2;
int textX = bitmapWidth;
int fontWidth = 5, space = 1;

/*
 * drawText
 * Draw each char to LED
 */
void drawText(String s, int x)
{
    int y = 0;
    for(int i = 0; i < s.length(); i++) {
        Serial.println(s[i]);  
        led->drawChar(x + i*(fontWidth+space), y, s[i], true, false, 1);
    }
}

/*
 * createDisplay
 * Create the LED
 */
void createDisplay() {
    led = new LEDMatrix(4, 1, D0, D1, D2);
    led->addMatrix(3, 0, 0, false, false);
    led->addMatrix(2, 0, 0, false, false);
    led->addMatrix(1, 0, 0, false, false);
    led->addMatrix(0, 0, 0, false, false);
    textX = bitmapWidth;
}

/*
 * killDisplay
 * Tear down the LED
 */
void killDisplay() {
    led->shutdown(true);
    delete led;
    led = NULL;
    iterationCount = 2;
}

/*
 * displayMessage
 * take a String param, kill any existing display, sound peizo and reset iterationCount
 */
void displayMessage(const char *event, const char *data) {
    killDisplay();
    createDisplay();
    tone(speakerPin, 301, 1000);
    message = data;
    Serial.println(message);
    iterationCount = 0;
}

/*
 * setup
 * enable serial logging + create LED
 * Listen for 'matrix_display_message' and fire off to displayMessage
 */
void setup() {
    Serial.begin(9600);
    createDisplay();
    // on 'matrix_display_message' call display_message
    Mesh.subscribe("matrix_display_message", displayMessage);
}

void loop() {
    if(iterationCount < 2 && message != "") {
        drawText(message, textX--);
        
        int length = message.length();
        if(textX < length*(fontWidth+space)*(-1) ) {
            textX = bitmapWidth;
            led->flush();
            delay(333);
            led->fillScreen(false);
            iterationCount++;
        }
    
        led->flush();
        delay(50);
    } else {
        iterationCount = 2;
        message = "";
    }
}

/// This #include statement was automatically added by the Particle IDE.
#include "adafruit-led-backpack.h"

Adafruit_7segment matrix = Adafruit_7segment();
int count = 0;

void logToDisplay(const char *event, const char *data) {
  digitalWrite(D7, HIGH);
  delay(1000);
  digitalWrite(D7, LOW);
  count++;
  matrix.print(count);
  matrix.writeDisplay();
}

void setup() {
  Mesh.subscribe("matrix_display_message", logToDisplay);
  matrix.begin(0x70);
  matrix.print(count);
  matrix.writeDisplay();
}

void loop() {}

version: 2
jobs:
  build:
    working_directory: ~/repo
    docker:
      - image: circleci/node:8
    steps:
      - checkout
      - run: npm install
      # npm scrip 'foo' does not exist, so should fail
      - run: npm foo
      - run:
          name: Build Success
          when: on_success
          command: |
            if [ "$CIRCLE_NODE_INDEX" == 0 ]; then
              echo "Success"
            fi
      - run:
          name: Build Failed
          when: on_fail
          command: |
            if [ "$CIRCLE_NODE_INDEX" == 0 ]; then
              curl -d '{ "branch": "'"$CIRCLE_BRANCH"'", "user": "'"$CIRCLE_USERNAME"'"}' -H "Content-Type: application/json" -X POST https://mesh-circle-ci.chrisbuttery.now.sh/api/display
            fi

require("dotenv").config()

const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')
const path = require('path')
const app = express()
const particle = require('particle-api-js')

const Particle = new particle()
const portNumber = 8000
let auth = null

// credentials
const deviceId = process.env.PDEVICE
const username = process.env.PUSER
const password = process.env.PPASS

// middleware
app.use(cors())
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))

// routes
app.post('/api/display', async (req, res, next) => {
  const { branch, user } = req.body  

  if (!auth) {
    await Particle.login({username, password})
      .then(data => {
        auth = data.body.access_token
      })
      .catch(({ status, message }) => 
        res.status(status).send({ error: message })
      )
  }

  const message = `Broken Build! ${branch} | ${user}`
  await Particle.callFunction({
    deviceId,
    name: 'display_broken_build',
    argument: message,
    auth
  })
  .then((data) => res.send(message))
  .catch((err) => {
    console.error(err)
    res.send(`callFunction error: ${JSON.stringify(err)}`)
  })

  next()
})

// error handling
app.use((err, req, res, next) => 
  res.status(422).send({ error: err.message })
)
// Go!
app.listen(portNumber, () => console.log(`Listening on port ${portNumber}`))

Credits

Chris Buttery

2 projects • 1 follower

Full Stack Software Developer. JavaScript, nodeJS, elm, CSS and IoT.

Broken CircleCI Builds and Particle Mesh

Things used in this project

Hardware components

Software apps and online services

Story

CircleCI

API

Argon (Gateway)

Xenon - Scrolling Marquee (Endpoint)

Xenon - Counter (Endpoint)

Conclusion

Schematics

Argon (Gateway)

Xenon (Marquee)

Xenon (Counter)

Code

package.json

argon-publish.ino

xenon-subscribe-scrolling-marquee.ino

xenon-subscribe-counter.ino

config.yml

package.json

.env

index.js

now.json

Credits

Chris Buttery

Comments

Embed the widget on your own site

Broken CircleCI Builds and Particle Mesh

Broken CircleCI Builds and Particle Mesh

Things used in this project

Hardware components

Software apps and online services

Story

CircleCI

API

Argon (Gateway)

Xenon - Scrolling Marquee (Endpoint)

Xenon - Counter (Endpoint)

Conclusion

Schematics

Argon (Gateway)

Xenon (Marquee)

Xenon (Counter)

Code

package.json

argon-publish.ino

xenon-subscribe-scrolling-marquee.ino

xenon-subscribe-counter.ino

config.yml

package.json

.env

index.js

now.json

Credits

Chris Buttery

Comments

Related channels and tags