Options

I can either attach the UPS to my linux server with NUT as primary then setup Synology NAS as secondary. Or, reverse it with Synology NAS as primary with linux as secondary. There are many other factors but, ultimately, primary has to stay up longer than secondary to avoid unexpected behavior caused by loss of communication to primary. Additionally, given that my linux server consumes more raw power than my Synology, it was an obvious decision to make Synology my primary.

Synology UPS Setup

To setup local UPS support, connect the UPS device to a USB port of the Synology NAS. Login to your DSM and navigate to “Control Panel” then click “Hardware & Power”. Under the UPS tab, “Enable UPS support” and select “USB UPS”. In my case, I want to gracefully shutdown after 5 minutes – not have it running “Until low battery”

Tick “Enable network UPS server” to allow NUT client to connect to this service as secondary. Click “Permitted DiskStation Devices” and enter the client IP address – in my case, this would be my linux server’s fixed IP address.

Click “OK” then click “Apply”. You now have NUT service running on Synology as primary.

Extract Required NUT client details

To access required data to properly configure NUT client, you must login to DSM via terminal over SSH. From DSM, go to “Control Panel” and click “Terminal & SNMP”. Under “Terminal” tab, tick “Enable SSH service”.

SSH into DSM as user with administrative role. Once logged in, run sudo tail /etc/ups/upsd.users command. Look for the line password = <password>, note this password down. Prior to the password line, note down the username defined within square brackets ([monuser]). Then, run sudo tail /etc/ups/ups.conf. The name within square braces is the UPS name. See green outline in screenshot

Linux Server Setup as NUT client

Pre-requisite

First install Network UPS Tools – if not already installed

$ sudo apt update
$ sudo apt install nut

Setup NUT Monitor

First, configure NUT as netclient by editing /var/nut/nut.conf. Look for MODE and change it to netclient

MODE=netclient

Then, edit /etc/nut/upsmon.conf to add MONITOR line with the name capture from ups.conf along with the monitor user (e.g. monuser) and password from upsd.user from above Synology section.

MONITOR <name from ups.conf on synology>@<ip address of your synology> 1 <monitor user from above> <password from above> slave

Then setup NOTIFYFLAG. If NOTIFYFLAG are commented out, please add the follow. Otherwise, edit them according.

NOTIFYFLAG ONLINE     SYSLOG+EXEC
NOTIFYFLAG ONBATT     SYSLOG+EXEC
NOTIFYFLAG LOWBATT    SYSLOG+EXEC
NOTIFYFLAG FSD        SYSLOG+WALL+EXEC
NOTIFYFLAG COMMOK     SYSLOG+EXEC
NOTIFYFLAG COMMBAD    SYSLOG+EXEC
NOTIFYFLAG SHUTDOWN   SYSLOG+WALL+EXEC
NOTIFYFLAG REPLBATT   SYSLOG+WALL+EXEC
NOTIFYFLAG NOCOMM     SYSLOG+WALL+EXEC
NOTIFYFLAG NOPARENT   SYSLOG+WALL+EXEC

The SYSLOG will trigger logging. WALL will send message to all terminal sessions. The EXEC command will trigger script defined by NOTIFYCMD. This will be further discussed in next section.

NOTIFYCMD /usr/sbin/upssched

This will enable NUT to monitor your UPS status on Synology and notify and/or execute action

Setup NUT Schedule

When UPS notification occurs, NOTIFYFLAG is used to perform actions for a given notification type. For example, when UPS moves to battery mode, ONBATT will be triggered. In the above case, It will perform SYSLOG which will log to /var/log/syslog and EXEC will trigger the script defined by NOTIFYCMD. When power is restored to UPS, ONLINE will be trigger.

Edit /etc/nut/upssched.conf uncomment the following line. This sets the file name of the First In First Out (FIFO) between processes to start and stop timer.

PIPEFN /run/nut/upssched/upssched.pipe

Then uncomment the following line. This will prevent race condition.

LOCKFN /run/nut/upssched/upssched.lock

Add the following commands

AT ONLINE * EXECUTE online
AT ONBATT * EXECUTE onbatt

Search for CMDSCRIPT and edit the file referenced (e.g. /bin/upssched-cmd). Replace with following:

#! /bin/sh
#
# This script should be called by upssched via the CMDSCRIPT directive.
#
# Here is a quick example to show how to handle a bunch of possible
# timer names with the help of the case structure.
#
# This script may be replaced with another program without harm.
#
# The first argument passed to your CMDSCRIPT is the name of the timer
# from your AT lines.

UPS="<name from ups.conf on synology>@<ip address of your synology>"

STATUS=$( upsc $UPS ups.status )
CHARGE=$( upsc $UPS battery.charge )
CHMSG="[$STATUS]:$CHARGE%"

case $1 in
        online)
                MSG="$UPS, $CHMSG - power supply has been restored."
                /sbin/shutdown -c
                ;;
        onbatt)
                MSG="$UPS, $CHMSG - power failure - save your work!"
                /sbin/shutdown -h +2
                ;;
        lowbatt)
                MSG="$UPS, $CHMSG - shutdown now!"
                /sbin/shutdown -h now
                ;;
        upsgone) MSG="The UPS $UPS has been gone for awhile" ;;
        *) MSG="$UPS, $CHMSG - Unrecognized command: $1" ;;
esac
logger -i -t upssched-cmd $MSG

In above example, when NOTIFYFLAG ONBATT occurs, it will execute /usr/sbin/upssched defined by NOTIFYCMD. This will trigger AT ONLINE * EXECUTE online which will call /bin/upssched-cmd defined by CMDSCRIPT. In /bin/upssched-cmd onbatt case will result execute shutdown in 2 minutes (see /sbin/shutdown -h +2). However, when power is restored, the online trigger will cancel the shutdown (see /sbin/shutdown -c).

Restart NUT Monitor

Reload NUT monitor with the latest changes by executing following commands

$ sudo service nut-monitor stop
$ sudo service nut-monitor start

To test, unplug your battery from power source to trigger ONBATT notification then plug it back in. If everything is setup correctly, you should see in the /var/log/syslog similar to below.

In the realm of building the right solution, business domain is not just a backdrop; it’s a pivotal player in the interpretation and understanding of requirements. The importance of context cannot be overstressed, as it is the lens through which we perceive and make sense of the requirements. Without good understanding of the business domain, the result is “blind leading the blind” solution. Successful software engineers, who take the time to understand the context they operate in, provide higher value.

Context is the invisible force that molds our understanding of product intent. It is the difference between a solution that resonates and one that falls flat. As we navigate through daily agile ceremonies, recognizing and understanding the context will lead to more successful product and overall solution.

Rather than reviewing all the facts, we too often hold onto our beliefs. Ask a front-end developer which library/framework should be used for a given project, it’s rarely followed by a question on what the requirements are. Rather, if they are a ReactJS developer, they will automatically respond with ReactJS. An Angular developer is no different. We end up choosing a solution first then justify its fit. Just ask why ReactJS is better solution, they will point to facts like, “it’s the most downloaded library”

By that logic, I should just go buy a Ford F-Series truck. If I’m an eco-friendly individual that never needs the truck to carry loads, maybe I don’t need a truck. Maybe an electric vehicle is a better fit. Yet, because it is the most sold vehicle in America, do you think it’s the right fit. Failure to take into considerations of the facts of the requirements and/or the make-up of the engineering team, we do a disservice to our clients/customers.

How to Avoid Confirmation Bias?

Discuss your thoughts with others. Don’t jump to conclusions. Gather as much facts. Surround yourself with a diverse group of people, and don’t be afraid to listen. The simplest way to avoid confirmation bias is to look at your own beliefs. Search out ways in which your default solution may be wrong, rather than the ways in which it is right. Always be learning. Seek out competitive solutions and learn from it.

I tend to stay away from mainstream fad – especially those on social media platforms. I did, however, read the article on New York Times – who later purchased it for 7-figures. Eventually, I gave in and played to see what the craze was about. To my surprise, I was instantly hooked. I was surprised by the simplicity of it. I’ve written 2 mobile games that I published on both Apple App Store and Android Play Store – both failed to retain players. My games were too monotonous and lacked meaningful engagement to maintain revisit. I never considered the “less is more” approach. The simple idea of releasing one puzzle a day is genius.

This brings me to the title, “7-Minute Abs.” An old colleague mentioned it when I shared WordHex, an app I created over the weekend. “7-Minute Abs” is a scene from “Something About Mary” where the hitchhiker shares his business idea based on “8-Minute Abs” but in 7 minutes! It’s a little spot on.

I created WordHex based on Wordle except it’s 6-letter words. One puzzle a day was just not enough for me. I wanted to play another round. I also hadn’t coded in a while. Last time I did, it was in golang – I may share the back story on that in the future. WordHex is available in beta. Once it’s stable, a friend suggested I create one for 4-letter, 7-letter, and 8-letter words as well.

If you do find Wordle entertaining and, like me, can’t wait another day; please visit WordHex.

Look, it’s not like this is my New Year’s resolution or anything like that. Let’s see if I can try to post at least once a month. And yes, I get credit for this post towards January.

Chain of Responsibility

The chain of responsibility design pattern is known as a behavioral pattern consisting of client objects and a series of handler objects. It provides more than one object the opportunity to handle a request by linking receivers together (see left UML diagram). Instead of having one monolithic class, as I have or coupling your code to each and every concrete class, with the chain of responsibility pattern, you can avoid both.

Refactoring Rotation Controller

On the right is the UML diagram for handling user inputs in my game. The ControlListener implements the Java AWT Event KeyListener. The ControlListener listens for various keyboard actions (UP_ARROW – rotate clockwise, DOWN_ARROW – drop, LEFT_ARROW – move left, RIGHT_ARROW – move right, Q – rotate counter-clockwise, and W – rotate clockwise). When user presses UP_ARROW, Q, or W, it will create an instance of RotateController class to handle the respective rotation action. On the original UML diagram, you can see the long list of private methods I’ve implemented to handle the rotation action for various tetris shapes.

On the left is the refactored UML diagram with the rotation logic implemented using the chain of responsibility design pattern. Gone are the many private methods created to handle every possible shapes. For each shape, we now have a respective handler class responsible for rotating the shape. The chain of these rotation handler will check if can handle the rotation request by inspecting the shape associated with the request.

public Coordinate[] executeRequest(RotateRequest request) {
  final Coordinate[] coordinate;
  final IShape shape = request.getShape();
  final Rotate rotate = request.getRotate();

  if( shape.getShape() == this.getShape()) {
    coordinate = getTargetCoordinates(shape, rotate);
  } else {
    if(this.nextHandler == null) {
      throw new HandlerNotFoundException("No handler defined for " + shape.getShape());
    } else {
      coordinate = this.nextHandler.executeRequest(request);
    }
  }

  return coordinate;
}

If it cannot handle the request, it will pass the request to the next handler. If it reaches the end of the chain and no handler is found, a runtime exception will be thrown. Feel free to browse the final code base on GitHub.

WSDL to Java
Recently, I published one of my old SharePoint API to GitHub. Originally, I had written the build script using Ant for this project. One of the task I had was to take the SharePoint List WSDL and generate the corresponding java soap client classes. This is fairly trivial task in Ant – in fact, axis already provides an ant task. Sure, I could google for Gradle plug-in for WSDL to Java but I wanted to use this opportunity to learn to write my own plug-in. I’ve also been looking to write more Groovy code.

Creating a Custom Gradle Task
All custom Gradle tasks resides under buildSrc at the root of your project. If you are familiar with Gradle multiproject then you will notice that buildSrc is structured like a subproject. In fact, it is a subproject. Since I will be writing my custom task using Groovy, my source file will reside under src/main/groovy. If you wanted to write your custom task in Java, you would create it under src/main/java.

Since my custom task is merely a wrapper for Axis2 class org.apache.axis2.wsdl.WSDL2Java, the build.gradle file will contain the Axis2 dependencies. Note, if your custom task does not require any dependencies besides core java, then you do not need to define the build.gradle file. Here’s my build.gradle file:

repositories {
  mavenCentral()
}

dependencies {
  compile 'org.apache.axis2:axis2:1.6.2'
  compile 'org.apache.axis2:axis2-xmlbeans:1.6.2'
  compile 'org.apache.xmlbeans:xmlbeans:2.6.0'
}

Once the build.gradle has been defined, I create my custom task in Groovy – WSDL2Java.groovy. The below Groovy class is a simple implementation. As you can see, there are no validation checks. It assumes all properties will be set.

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
// since this groovy class has the same name as the axis2 class, alias axis2 class to CodeGen
import org.apache.axis2.wsdl.WSDL2Java as CodeGen

class WSDL2Java extends DefaultTask {
  // source location of the WSDL file
  String wsdlfilename
  // specify the binding type - xmlbeans, adb, or jibx
  String databindingName
  // target location where java classes should be created under
  String targetSourceFolderLocation
  // base package name
  String packageName

  @TaskAction
  def generateJava() {
    String[] args =
      [
        "-o", targetSourceFolderLocation,
        "-p", packageName,
        "-d", databindingName,
        "-or",
        "-uri", wsdlfilename
      ]
    CodeGen.main(args)
  }
}

Here’s how this custom task is called within the project. First, I define a task called “genJavaFromWSDL” with type WSDL2Java – the Groovy class name. Within this custom task, I set all properties. Then, I update the dependency of java compile task to this custom task. This will ensure the java soap client is created before build is trigger.

// define the WSDL2Java task
task genJavaFromWSDL(type: WSDL2Java) {
  wsdlfilename= "$buildDir/../src/main/wsdl/Lists.SP2013.wsdl"
  databindingName='xmlbeans'
  targetSourceFolderLocation= "$buildDir/generated/wsdl/main"
  packageName='com.microsoft.sharepoint'
}

// add prior hook before compile
compileJava.dependsOn genJavaFromWSDL

// add generated wsdl java classes to source dir
sourceSets.main.java.srcDir "$buildDir/generated/wsdl/main/src"
sourceSets.main.java.srcDir "$buildDir/generated/wsdl/main/resources"

Finally, I add the generated source and resources to the Groovy sourceSet so that the generated sources are properly compiled. It also allows them to appear under Eclipse.

SharePoint API
Several years ago, I wrote a SharePoint API in Java to interact with its List Soap Service. This soap service had a feature to query the target list using Collaborative Application Markup Language (CAML). Here’s an example of CAML query to filter the task list where the TaskName is “Foo Bar” and the Status is “In Progress”.

<query>
  <where>
    <and>
      <eq>
        <fieldref name="TaskName">
        <value type="Text">Foo Bar</value>
      </fieldref></eq>
      <eq>
        <fieldref name="Status">
        <value type="Text">In Progress</value>
      </fieldref></eq>
    </and>
   </where>
</query>

As part of this SharePoint API, I had written a corresponding set of Java classes – each node represented by a class. For trivial query like above, it would look like the following:

final Expression leftExpression = new Equals(new Field("TaskName", "Foo Bar"));
final Expression rightExpression = new Equals(new Field("Status", "In Progress"));
final Condition condition = new And(leftExpression, rightExpression);
final Where clause = new Where(condition);
final Query query = new Query(clause);

As you can predict, for complicated scenarios, this would quickly become unreadable. By applying the concept of Fluent Interface, we can make it far more readable. For example, the above become the following:

final Where clause =
  new Where(
    and(eq("TaskName", "Foo Bar"),
        eq("Status", "In Progress")));

Applying Fluent Interface
A good Fluent Interface takes a while to build. It should be built with the goal of readability and flow in mind. Return type should be chosen based on what you need to continue fluent action. Here’s the SharePoint API implementation. For the complete implementation, please see GitHub Source.

.
.
.
public static Condition and(Expression left, Expression right) {
  return new And(left, right);
}

public static Condition and(Expression left, Condition right) {
  return new And(left, right);
}

public static Condition and(Condition left, Expression right) {
  return new And(left, right);
}

public static Condition and(Condition left, Condition right) {
  return new And(left, right);
}
.
.
.
public static Expression eq(Field field) {
  return new Equals(field);
}

For complicated scenarios where you want to get all task assigned to John with status in “New” or “In Progress” and task created after Jan 1, 2014, the CAML would like the following.

<query>
  <where>
    <and>
      <eq>
        <fieldref name="AssignedTo">
        <value type="Text">John</value>
      </fieldref></eq>
      <and>
        <or>
          <eq>
            <fieldref name="Status">
            <value type="Text">New</value>
          </fieldref></eq>
          <eq>
            <fieldref name="Status">
            <value type="Text">In Progress</value>
          </fieldref></eq>
        </or>
        <gt>
          <fieldref name="CreateDate">
          <value type="DateTime">2014-01-01T00:00:00Z</value>
        </fieldref></gt>
    </and>
   </and></where>
</query>

Here’s the same in Fluent Interface

final Where clause =
  new Where(
    and(eq("AssignedTo", "John"),
    and(
      or(eq("Status", "New"),
         eq("Status", "In Progress")),
      gt("CreateDate", "2014-01-01T00:00:00Z"))));

Application Monitoring

There are several things to consider when monitoring an application. This is not meant as an exhaustive list but here are few items:

• application state
• resource utilization
• proactively report application errors
• module/component status
• external dependency status (databases, services, etc.)

The monitor should be proactive and not reactive. It should provide early enough warning before something goes wrong. This includes monitoring dependencies and the application itself. There are tools that monitor logs and report when it detects various errors in the log file. Although this is better than nothing, it’s too reactive. If you’re lucky enough to have nagios in-house, this is better. However, in most cases, they are configured only for Production and, if lucky, QA. However, for other environments, it may be an overkill to use nagios.

Health Monitoring

The purpose of my health monitor tool is to provide a simple framework to quickly setup and actively check the overall health of any application.

Health monitoring tool is built on the following open source frameworks:

• quartz-scheduler – used to schedule recurring checks to verify your site, components/modules, and dependencies
• apache httpcomponents – used to retrieve resources (JSON/HTML) from HTTP/HTTPS servers
• grizzly NIO framework – used as embedded web container to host status page (see above screenshot)
• jackson – used to parse JSON resources and configuration
• freemarker – used for web/email template
• javamail – used to send failure notification

It can proactively check your application and its dependencies with predefined service checks:

• com.jstrgames.monitor.svc.impl.HttpService – make non-SSL web call
• com.jstrgames.monitor.svc.impl.HttpsService – make SSL web call
• com.jstrgames.monitor.svc.impl.SimpleJmxService – make simple remote JMX calls
• com.jstrgames.monitor.svc.impl.SocketService – make a client socket call

It can then verify these services with predefined rules:

• com.jstrgames.monitor.rule.HttpResponseCode – check if expected status code returned
• com.jstrgames.monitor.rule.HttpResponseBody – check if body contains expected values
• com.jstrgames.monitor.rule.JsonResponse – check if specified JSON key has expected value
• com.jstrgames.monitor.rule.SimpleJmxResult – check if specified JMX attribute has expected value

All can be configured on a simple JSON format configuration file.

Example: Checking HTTPS site

The use case is to verify that the text “Google Search” and “I’m Feeling Lucky” appears on the google.com page every 5 minutes:

[{"servicename": "HTTPS Example (SSL)",
  "classname": "com.jstrgames.monitor.svc.impl.HttpsService",
  "schedule": "0 0/5 * * * ?",
  "hostname": "www.google.com",
  "port": 443,
  "uri": "/",
  "rules": [{
    "classname": "com.jstrgames.monitor.rule.HttpResponseCode",
    "condition": "equals",
    "expected": 200
  },{
    "classname": "com.jstrgames.monitor.rule.HttpResponseBody",
    "condition": "contains",
    "expected": "Google Search"
  },{
    "classname": "com.jstrgames.monitor.rule.HttpResponseBody",
    "condition": "contains",
    "expected": "I'm Feeling Lucky"
  }]
}]

Here, class com.jstrgames.monitor.svc.impl.HttpsService is used check www.google.com at port 443. Once the resource has been retrieved, 3 rules are executed:

• verify http response code is 200
• verify http response body contains the phrase “Google Search”
• verify http response body contains the phrase “I’m Feeling Lucky”

If any of the above checks fails, service is considered to be in “FAIL” status. If it fails to connect to said service, it is in “ERROR” status. It will also send out a notification and user will see a similar content in their inbox, granted, not as pretty.

For more details, please go to my github repository. I will be updating its wiki page soon.