add results filed in TestDataSetDetailSerializer

adapt get_dataset_info in TestRecordDetailSerializer

add uuid field

add hash field form TestRecord model;add TestRecordDetailViewSet;

update basic-table

update TestRecordListSerializer;add trend field;

update the receiver

add calc_status receiver

add TestDataUploadError

add result parse in upload

add branch_data;add cate_sn field;

Add temporary data import

add alias dbtool

add CreateTestDateSetSerializer

add CreateTestRecordSerializer

add TestDataSet model class

Overwrite the table component

add machine serialler;render test list data;

fix CORS problem;add detailInfo function

add data upload interface

add testDetail viewSet

fix url problem

add token auth

adjust detail page layout

add related serializer

add TestRecord serializer

adjust model class

add result card component

add result.json sample

add detailInfo page

beautify table-list

update .gitignore

add case sensitive in .gitignore

adjust rate-bar color

add status-service

add wating state for applyBtn

accomplist table-list

accompilsh selectItem function

update rate-bar

add RateBat component

add pg font icon

update clearBtn function

add table util

add ppolicy page

add deleteItem func;

add selected items css

add selectItemClick function;

add general pagination

fix map issue

Separate filter conditions

add hover effect

add loggedin dom

add util.js

add login page

update readme.rst

Fix reference issues

modify filter component

modify settings.py

add apps,db_tools,extra_apps folders

online adapter

online adapter

online adapter

add front-end code

Refactor pgbench results output

The idea is that one results document represents a test of one
particular commit.  Then it contains the results of all the tests run
against that commit.  I think it makes more sense to restructure the
pgbench results to be like:

{
    "pgbench": {
        "ro": {
            "results at a scale factor": {
                "number of clients": {
                    "std": 4389.727756305762,
                    "metric": 41390.590287,
                    "median": 43137.716637,
                    "results": [
                        {
                            ... pgbench results of a test ...
                        }
                        ...
                    ]
                },
                ....
        },
        "rw": {
            ... read write test results ...
    },
    ... other tests results
}

Update default pgbench and postgresql settings

Make the default settings what we want to be tested.  The idea is to
minimize setup on the clients.

Use collectd for system and postgres statistics

Move results directory check to start of client

Between the benchmark and collector modules, it's not clear who might
have created the output directory first.  Leave a warning in the
benchmark modules for now, otherwise don't let it prevent the tests from
running.

Use https instead of git protocol

This is for ease of automated testing.  Using git:// can require manual
confirmation about updating the ssh known hosts file.

Add support for FreeBSD

The memory calculations for pgbench will need to be platform specific.
Also the system data collection may have to be platform specific.  Thus
far, just added conditions so that things will run on FreeBSD now.

Set default directories to /tmp

Set the default directories in the client settings.py file to use /tmp.
This will make it easier to automate testing by reducing the number of
settings to configure.

Set cwd when running pgbench

The output directory is used for the cwd when executing pgbench so that
the output files are saved in the results directory.

Update ignore file for ctags

Add sbin locations to PATH for sysctl

The location of sysctl may change depending on the distribution.  Try to
add all possible paths to the environment.

Add requirements.txt for the client

Force csv.DictWriter to create unix file format

Always write results of a test to results.json

The idea is to keep things simple by having a directory of results per
test, and to have each directory with a consistently named results
files.

Capture uname information

It has some things that are not in the sysctl information.  Like
hardware architecture.

Stop storing log files as json

Keep the json results document small by saving log information
externally.  This include:

* postgres log
* pgbench output
* sar output

Fix use of env in call()

The env parameter to call() was clearing the PATH environment to only
have the postgres binary install path.  Modify only the PATH
environment.

Install pgbench from contrib for older versions

Prior to 9.5, pgbench was in contrib.

Alter postgres options on the command line

This allows testing of older versions of postgres.  Otherwise only
versions of postgres supporting ALTER SYSTEM (9.4+) will work with this
client.

Saved timestamp from test start

Use python2.7 from environment settings

Pythonic way to check for None

Also check to make sure files exist before trying to collect them.

Fix check for csv flag

Fix handling of csv option

pep8 coding style

also add CSV output to pgbench

add support for collecting results into simple CSV file

Originally the results were collected into a JSON format, which is
not very convenient when running ad-hoc benchmarks.

add shebang explicitly invoking Python 2.7

The code is not fully compatible with Python 3.x (although it should
not be a big deal to make that happen).

explicitly flush stdout in log()

Otherwise the messages may get buffered for a quite long time, which
is annoying, particularly in multi-process system.

fix lockups in PostgreSQL collector

When the workers produce results and return them through a queue, we need
to first drain the queue and then wait for the thread to join(). Otherwise
it seems to lock up - the join() call with wait as long as there are items
in the queue. This also happens because we do both things (reading from
queue and waiting for the thread) in the same thread.

open connections in a way resilient to temporary failures

In case of connection failure (e.g. a backend getting terminated by
OOM killer and taking down the whole server), the workers failed
with an exception without putting a result into the queue, leading
to hangs.

This fixes that by making the workers resilient to connection issues
by catching the exceptions and terminating nicely. Also, we retry
connection several times, to continue with benchmarking even after
OOM hits us unexpectedly, etc.

Check configuration before running any benchmarks

Before doing any heavy-lifting, check existence of directories,
binaries and some other sanity checks.

Fix CWD when running 'git pull', fix parameters.

When refreshing a reporitory clone, running 'git pull $dir' does
not do the trick - it assumes the CWD is the clone, and imports
data from repository at $dir. So we need to set CWD properly and
do just 'git pull'.

Also, prefix class members with 'self'.

Add .lock to .gitignore

Rework the perffarm client configuration.

Instead of configuration hardcoded into the perffrarm-client.py
script, move it into a separate settings.py file, and allow
override using settings_local.py (not required).

Also somewhat improve the benchmark configurations by allowing
specifying number of runs, durations etc. in the configuration
file (instead of using default parameter values).

Handle missing sar stats gracefully

Import initial version of the client

Update requirements.txt