Need to make a quick json fixes – JSONPath for rescue

From time to time I have a need to do some fixes in my json data. In a world of flat files I do this with grep/sed/awk tool chain. How to handle it for JSON? Searching for a solution I came across the JSONPath. It quite mature tool (from 2007) but I haven't hear about it so I decided to share my experience with others. First of all you can try it without pain online: http://jsonpath.curiousconcept.com/. Full syntax is described at http://goessner.net/articles/JsonPath/ But also you can download python binding and run it from command line:
$ sudo apt-get install python-jsonpath-rw
$ sudo apt-get install python-setuptools
$ sudo easy_install -U jsonpath
After that you can use inside python or with simple cli wrapper:
#!/usr/bin/python
import sys, json, jsonpath

path = sys.argv[1]

result = jsonpath.jsonpath(json.load(sys.stdin), path)
print json.dumps(result, indent=2)
… you can use it in your shell e.g. for json:
{
  "store": {
    "book": [
      {
        "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      {
        "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      {
        "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      {
        "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}
You can print only book nodes with price lower than 10 by:
$ jsonpath '$..book[?(@.price < 10)]' < books.json
Result:
[
  {
    "category": "reference",
    "price": 8.95,
    "title": "Sayings of the Century",
    "author": "Nigel Rees"
  },
  {
    "category": "fiction",
    "price": 8.99,
    "title": "Moby Dick",
    "isbn": "0-553-21311-3",
    "author": "Herman Melville"
  }
]
Have a nice JSON hacking!

Enums for scala

Scala has very limited implementation of Enumeration. Enumerated objects can't extends other classes. Partial replacement for it is to use sealed classes. You can do pattern matching on them. When you ommit some possible value you will get compiler warning for not exhaustive pattern matching. One missing feature is that you can't get sorted values of all objects extending them. You can simple got it using my (40-lines) EnumOf class from scala-enum. Examples below.

Declaration

sealed abstract class Color(red: Double, green: Double, blue: Double)

object Color extends EnumOf[Color] {
case object Red extends Color(1, 0, 0)
case object Green extends Color(0, 1, 0)
case object Blue extends Color(0, 0, 1)
case object White extends Color(0, 0, 0)
case object Black extends Color(1, 1, 1)
}

Usage

Color.values shouldEqual List(Red, Green, Blue, White, Black)

Color.valueOfOpt(
"Blue").value shouldEqual Blue
Color.valueOfOpt(
"NotExisiting").isEmpty shouldBe true

You can also enumerate on objects nested in instances

Declaration

case class DistanceFrom(srcCity: String, srcCoordinates: Coordinate) extends EnumOf[DistanceBetween] {

case object ToBerlin extends DistanceFromSrcCityTo("Berlin", Coordinate(52.5075419, 13.4251364))
case object ToNewYork extends DistanceFromSrcCityTo("New York", Coordinate(40.7033127, -73.979681))

abstract class DistanceFromSrcCityTo(val destCity: String, val destCoordinates: Coordinate) extends DistanceBetween {
override def srcCoordinates: Coordinate = DistanceFrom.this.srcCoordinates
}
}

sealed abstract class DistanceBetween {
def srcCoordinates: Coordinate

def destCity: String
def destCoordinates: Coordinate

def inKm: Int = Coordinate.distanceInKm(srcCoordinates, destCoordinates).toInt
}

Usage

val DistanceFromWarsaw = DistanceFrom("Warsaw", Coordinate(52.232938, 21.0611941))

DistanceFromWarsaw.ToBerlin.inKm shouldEqual
519
DistanceFromWarsaw.ToNewYork.inKm shouldEqual 6856

DistanceFromWarsaw.values.map(_.inKm) shouldEqual List(519, 6856)

micro-burn has Trello integration

After a few long evenings I've finally integrated micro-burn with Trello. All you need to run it for your Trello board is to write short configuration and run fat jar. It renders burndown chart visualising progress of cards on your board.

You can specify story points adding them in curly braces inside card title, use Scrum for Trello browser extension or define default story points number for user stories. Completed checklist items are treated as a part of work done inside card. You can manage sprints on your own: creating new, specifying start/end/name, finishing or turn on full automatic mode: sprints will be created periodically.

Sprint management in usage:

Sample for lift-ng: Micro-burn 1.0.0 released

During a last few evenings in my free time I've worked on mini-application called micro-burn. The idea of it appear from work with Agile Jira in our commercial project. This is a great tool for agile projects management. It has inline tasks edition, drag & drop board, reports and many more, but it also have a few drawbacks that turn down our team motivation.

Motivation

From time to time our sprints scope is changing. It is not a big deal because we are trying to be agile :-) but Jira's burndowchart in this situation draw a peek. Because in fact that chart shows scope changes not a real burndown. It means, that chart cannot break down an x-axis if we really do more than we were planned – it always stop on at most zero. Also for better progress monitoring we've started to split our user stories to technical tasks and estimating them. Original burndowchart doesn't show points from technical tasks. I can find motivation of this – user story almost finished isn't finished at all until user can use it. But in the other hand, if we know which tasks is problematic we can do some teamwork to move it on. So I realize that it is a good opportunity to try some new approaches and tools.

Tools

I've started with lift framework. In the World of Single Page Applications, this framework has more than simple interface for serving REST services. It comes with awesome Comet support. Comet is a replacement for WebSockets that run on all browsers. It supports long polling and transparent fallback to short polling if limit of client connections exceed. In backend you can handle pushes in CometActor. For further reading take a look at Roundtrip promises But lift framework is also a kind of framework of frameworks. You can handle own abstraction of CometActors and push to client javascript that shorten up your way from server to client. So it was the trigger for author of lift-ng to make a lift with Angular integration that is build on top of lift. It provides AngularActors from which you can emit/broadcast events to scope of controller. NgModelBinders that synchronize your backend model with client scope in a few lines! I've used them to send project state (all sprints and thier details) to client and notify him about scrum board changes. My actor doing all of this hard work looks pretty small: Lift-ng also provides factories for creating of Angular services. Services could respond with futures that are transformed to Angular promises in-fly. This is all what was need to serve sprint history: And on the client side - use of service: In my opinion this two frameworks gives a huge boost in developing of web applications. You have the power of strongly typing with Scala, you can design your domain on Actors and all of this with simplicity of node.js – lack of json trasforming boilerplate and dynamic application reload.

DDD + Event Sourcing

I've also tried a few fresh approaches to DDD. I've organize domain objects in actors. There are SprintActors with encapsulate sprint aggregate root. Task changes are stored as events which are computed as a difference between two boards states. When it should be provided a history of sprint, next board states are computed from initial state and sequence of events. So I realize that the best way to keep this kind of event sourcing approach tested is to make random tests. This is a test doing random changes at board, calculating events and checking if initial state + events is equals to previously created state:

First look

Screenshot of first version:
If you want to look at this closer, check the source code or download ready to run fatjar on github.

Multi phased processing in scala

Last time in our project we had to add progress bar for visualization of long time running process. Process was made of a few phases and we had to print in which phase we currently are. In first step we conclude that we need to create a class of Progress which will be passed as an implicit parameter to our service. Then we will wrap method calls be inProgress method which will notify some e.g. akka actor about phase begin and phase end.



But this approach has some disadvantages. Firstly before we start service's operation we need to init progress with count of all phases to get know ratio of progress finish. With this approach we had to add some extra counting before operation start.





If we want to keep real progress notifications the numbers of phases had to fit count of inPhase blocks. Some of phases were dynamically computed and some where omitted in case of failure validations results. This code become to be unmaintained.

We found that we need to join computation of phases with real phase processing. In this case we need to change approach from building process to building chain of phases that will run the process. Each phase will take the result of previous phase and transform it to new output. So example process will look like this:



Code giving this chain functionality looks like this:



We've used right associative operator :: for building chain of phases. "Body" of phases is piped by andThen: processPrevWrapped andThen processNext. For nil-tail we need to have a factory creating empty chain with identity "body" function.

Also if we have this kind of tool, we can modify piping code according to nature of our flow. For example if we are using scalaz.Validation we can do validating chain which will extract a success from n-step output and pass it to input of next step (like flatMap). In the other hand if n-step will return Failure, we will skip all remaining phases of validating chain.



To make building of chain more production-ready we add some extra features:
  • Chaining of chains (sth like ::: in scala Lists)
  • Transforming of input/output - for adding some "glue" code for simpler phases chaining
  • Wrapping of chains - also some "glue" code doing both input and output transformations
  • Sequencing of chains - sequenced processing of multiple phases with the same input

If you are interested in using similar approach, take a look at my github project: scala-phases-chain. If you want to integrate this tool with akka actors, simply change MultiPhasedProgress.notifyAboutStatus method to look like this:

Journal.IO 1.3 released

About


Just a moment ago (in February 17th) Journal.IO 1.3 has been released. Journal.IO (https://github.com/sbtourist/Journal.IO) is a lightweight, zero-dependency journal storage implementation written in Java. We use it in our project for storing application events (Event Sourcing pattern). It is a good, stable solution if you want to have simple in use event storage e.g. if you want to implement lightweight queuing mechanism and JMS is overhead for you.

New version resolves some bugs and improves delete operation performance. Unfortunately new version uses new log format which isn't backward compatible. Therefore we decide to write a simple migrating tool for migrate 1.2 version compatible logs to 1.3 version.

Migrator


Migrator was written in groovy. It is available on github (https://github.com/arkadius/journalioMigration). Also link to the tool is available from official Journal.IO homepage. To use it simply run:



oldLogsRoot is recursively scanned for logs which are migrated parallel in 5 threads (used ASYNC read mode additionally speed up this process). Migrated logs are written in the same hierarchy in newLogsRoot.

Control your bandwidth using ntop

I was looking for tool which could help me check who is using my bandwidth. Here are requirements which I want from this kind of tool:
  1. local hosts bandwidth distribution - it is helpful when you are loosing your bandwidth and don't know who abuse it in your local network
  2. remote hosts bandwidth distribution - it is useful in situation when you want to have control over DoS attacks for your public homepage or when your QoS are not set well

Gargoyle

My first shoot is to check what features can give me my TP-Link TL-WR941ND router. I've installed on it Gargoyle (modification of OpenWRT with some additional features) some time ago. It has some useful monitoring features:
  • bandwidth distribution pie charts which answer for my first requirement but I can't check the time when bandwidth was used there

  • connections track - from this I can check two sides of connection (also remote host) and how much of data was send/received but it also doesn't show this information in time domain and it is served in less friendly, text form

It was no exactly what I'm looking for. Therefor I checked what what can we find in OPKG (OpenWRT Package Management).


SNMP + NagiosGraph

I tried to find how I can link Nagios (with NagiosGraph) with my router because I already have some experience with this tools. I found out that there is check_snmp Nagios plugin which can realize this. In OPKG there is mini-snmpd package. It is light SNMP server implementation. You can run it after login by SSH to you router and execute this command:

After this you can check available from server data:

In returned MIB tree there are some useful data like server's uptime, disk space and also interface's bandwidth. The last one, stored in Round Robin Database and printed by NagiosGraph will give graphs of bandwidth usage in time domain. But will not show who exactly use bandwidth!

Other software

I continue searches in OpenWRT packages. I came across good OpenWRT wiki page: http://wiki.openwrt.org/doc/howto/bwmon describing some available stuff.

ntop

Among other there is mentioned ntop - extensive application written in C with many views showing statistics of network protocols usage. Installation of this application on my router with 400MHz CPU will be not the best idea. So I tried to install it on my home server and only send data to it from router by fprobe. At first I installed ntop available from ubuntu 12.04 server's APT repository. There is available 3:4.1.0+dfsg1-1 version. After some simple configuration steps ntop start drawing graphs.

I simulate situation when from remote server I was downloading a big file from my home server. I was disappointed when noticed that I can't read that this situation taking place from ntop graphs.

listening on interface in promiscuous mode

Some time ago I've done tcpdump logs analyzer on my studies. I remind that interface working in promiscuous mode can collect all data about local network traffic just like the router. To enable this mode you should exec this command:

Or if you want to set this state persistent you should edit your /etc/network/interfaces to look like this:

If the server where you want to listen for all packages is a VirutalBox vhost you should also verify that it is set promiscuous mode to ''Allow all'' in their network configuration like on screenshot below.

ntop v.5.0.2

After this settings we can run ntop on any server in our local network. I give a try for a development version which you can download from ntop homepage: http://www.ntop.org/get-started/download/. Configure script led me through necessary packages that you must install before compilation. After this I run make and sudo make install. To manage ntop using init scripts I used existing /etc/init.d/ntop script and just edited a line with location of DEAMON value - setting them to /usr/local/bin/ntop value. I also removed -n 0 switch from /etc/default/ntop because I hope that bug with DNS resolution is already fixed (it is a little note in config about it).

I started deamon by service ntop start. In syslog there was nothing alarming - ntop started collecting traffic statistics. After login I checked available features.
  • Network load - this page shows all load in our network in four time intervals: 10mins, last hour, last day, last month
  • Top talkers - similar to network load intervals, shows how hosts were using bandwidth in past
  • Traffic maps: Region map & hosts map - ntop is connected to Google Maps and shows where are located hosts that we are talking to
  • Activity: how changes activity of hosts in every hour
  • And other - there are other useful things like Protocol statistics, Map of connections between hosts generated in dot and many more
After some tests I noticed that now I have full control about how my network is used (also find out that I have some scheduled script that every minute send unnecessary MBs of data ;-)).

little fix

This tests help me find out that there is a little bug in page showing top talkers of an hour. I submitted patch fixing it to ntop's request tracker if you are interested in: http://sourceforge.net/tracker/?func=detail&aid=3559097&group_id=17233&atid=367233. This is a patch to r5644.

On the end

My adventure with traffic monitoring tools ended on ntop. It is a great tool which fits my needs. Now I know who consumes my resources and can set QoS rules which make my internet connection more responsive.

Rapid js + css development

Background

Last time I had some work to do in OSGi web module written in Spring MVC. If we have application splitted to well-designed modules, back-end development in this framework run in OSGi environment is quite fast because after some modification we must update only one bundle (without dependencies). But programming in front-end is much less dynamic than in in modern frameworks like Ruby or Groovy. There is no build-in support to update resources "on the fly" after their modification (or I can't find it).

There is many plugins to web browser which help you build front-end from scratch in wysiwyg mode. But I can't find any which could modify resources of already ran application. Also it will be complicated to keep synchronized these modifications with our sources. Therefore I tried to use local links to my project in my application. I put code similar to this below in my page.



After redeploy I found in my Chromium console: Error::Not allowed to load local resource: file:///path/to/my/local/resource.js. After some googling I found solution: adding --allow-file-access-from-files switch to application. Unfortunately it doesn't work on my Chromium v.18. I also checked other switches: --disable-web-security and --allow-file-access but with no effect. I also tried  LocalLinks plugin but with the same result.



Solution

I found out that the simplest walkaround to this problem is to link my local resources directory in Apache2 web root. So i did this:



After this inclusion of script looks like:

As you can see, it is only difference in port in new location of script. So maybe there is a tool which helps in automatic replace this string?

Tampermonkey script

In Firefox I've been using Greasemonkey plugin which could do automatic code replacement like this on the fly. On Chrome there is Tampermonkey which is a port of Greasemonkey. I wrote script which do this thing for me:



What the script do?

It simply add on end of <head> script includes from location with replaced string from -> to. It also modify CSS link hrefs using the same approach. Both scripts and links are filtered using blacklist - it is helpful if our application using external resources.

Result

Now I can spend all of my time intended for development only writing a code. After any modification I only refresh a page in browser (I'm using IntelliJ Idea so instant autosaving is working for me). And what solutions of this problem you are using?