Script for processing log entries

Only recalculate balance if it is older that one minute

Calculate balance on first request

Aquarium configuration for use in benchmarking

Architecture diagram

Finish architecture

Script to generate rate limited (msg/sec) load

Continuation of T/dT, U/dU reasoning

Describing charging dimensions

Rename Billing to Computational aspects and move after Architecture

Finishing (for now) the description of events

Add events modeling.

AquariumEvent and ResourceEvent.

Start describing events

Slight reorg (Implementation -> Domain Modeling).

1. Added terminology
2. Moved stuff from the DSL description to the basic terminology
3. Started using term `charging` instead of `billing`

More on architecture

Initial architecture blurb

Start describing billing-related stuff.

Split arhitecture in another file to avoid conflicts

Alternative way to calculate state, with entry points commented out

Query to retrieve all events that comprise the history of an event

Names for event store fields

Configurable number of users to init (up to 1000)

Don't remove all mongo records after test run :-)

Log verbosity--

Parametrise number of actors to spawn, more threads for reading from store

Events are now replayed correctly

The correct name of the field is occuredMillis

Compilation fixes

Support for replaying event logs to construct the user runtime state

Properly shutdown user actors on Aquarium shutdown

Save user state on shutdown

Method to delete user state from store

Take care of first time state changes

WIP on the algos documentation camp

Simplify resources snapshot to make our lives easier with the lift-json library.

After a few failed attempts with lift-json, I sacrifice the Map for a List.

Give the option of pretty or non-pretty json printing

More on billing

Bit of text rearrangement, billing descriptions

Store the last update timestamp per resource and instance id

This code has some errors with JSON serialization

Simple test to try serialization of the complex user state class

Method to assert that an exception is not thrown

A great contribution to the paper.

Super documenter. Work in progress.

An attempt is being made to work the algorithms in plain prose.
Hopefully, this will help everyone get a better understanding of the
complexities involved and of the quite interesting problem domain.

As I said, this is Work in Progress...

Add a few helper methods to resource event

Don't store the whole agreement to the user state

Store a reference by name instead.

Case objects instead of objects for cost policy definitions

The log string has 2 args, not 3

Store the newly created user actor in the LRU cache

Use the list of resources defined in the policy

Do not use default global value parameter and take advantage of pattern case class matching

Augment DSLCostPolicy with utility methods

Refactor getInstanceId to not rely on global variables

Equality is always a possibility

Catch a message that is sent anyway

Ignore some auxilary latex files (emacs)

Implementation experience

Consistent `Id` naming (II)

Forgot these cases when I refactored for the previosu commit.

Consistent `Id` naming

Style: do not use return

Fix a couple of compilation warnings.

We still get the `head` though (via next), so the semantics are similar.

WIP on user get balance request.

Puting everything in line with the rest of the system implementation.

Find previous wallet entries for this event

Names for fields in the Json representation of the msg

Spice up WalletEntries with resource and instance info

Eliminate pattern matching since I am not doing anything with the specific cases

Small refactoring to ensure user state

Fill in and use UserState snapshots from DB.

Add documentation for store-related collections, give better names and fix a couple of bugs

Take into account active snapshot for timestamp computations

Use DEBUG shortcuts

Handle UserEvent in UserActor

Small doc addition for UserEvent

Remove unused subclasses of UserDataSnapshot

Collection renaming a bug fix in UserState query

Make UserState roles immutable

Add a few queries to UserEvent

Forward UserState events to dispatcher

More tests => several errors fixed

Add new discrete resource, test method to parse Maybe's

More precise error message

Calculate hours, not minutes

Generify EventProcessorService to avoid too many casts

Use UserDataSnapshotException

Refactor user state change code

Some text on Aquarium requirements and benchmarking

Accounting changes, too many to commit individually:

-Make the resource state store hold values in a uniform format for
 complex and simple resources
-Make the resource state retrieval method simpler and also contain
all resource state storage conventions into it.
-Implement the cost policy algorithms in the accounting method.
Separate accounting for complex/simple resources
-Docs++

Remove wrong test

Correct unit names

Convert a timeslot to its duration in hours

States for discrete cost policy events

Stricted definitions and explantations for cost policies

Skeleton for the Aquarium architectural description

Remove the resource state API, start using the new accounting code

Purify the accounting code

-All required resource state passed as params
-Charge chunks exposed as top level entity

Support for user configurable accounting policy locations

Make the number of MongoDB connections a configurable property

Various performance related changes

-Start lots of actors by default, to compensate for slow I/O
-Start a fair amount of threads by default
-More detailed logging
-Don't create a new dispatcher per request

Create a new connection per store request

This is to take advantage of the Mongo driver connection pool

Logging format similar to Akka's default

Implement the remaining bits of the user event processor service