anthony-kolesov / kts46 Goto Github PK

Implement Scheduler-Worker protocol v0.1 at Scheduler side:
  * runJob
  * getJob
  * reportStatus

If special cmd argument is specified then get worker id from it. If there is no 
argument then generate it using uuid.uuid4().
May it makes sense also to try to get id from configuration file.

If two cars at same positions on lines separated by one line will move to it at 
one time they will occupy the same place.

Extract initialization of ConfigParser to common lib function. This function 
will take as a argument tuple of configuration file paths and will return a 
SafeConfigParser instance.

Now node can have only one worker at a time. To ease node management add 
ability to start pool of workers from one node.

JSON API doesn't understand '-' in project names.

In all server components add command line arguments switch that will disable 
output of log data to console. That will be used in background runs so program 
will not waste time on meaningless console output.

in WebUI export statistics data in CSV format for selected rows.

If job is simulated again than it counter of progress is not reseted.

Now model can only be used from initial state. To be able to split jobs on 
partial tasks it is required to load state from JSON. 

Worker do task without db and scheduler: use yaml file as input and generate 
output csv files.

Create some starting-stopping script for all kts46 daemon processes:
  * RPC server
  * scheduler
  * worker (at first it must be implemented as daemon process, see issue #11).

Implement more sophisticated model of distance to leading cars: function 
depending on driver aggression level.

Splitting road and traffic flow into two.

Currently processes are stopped by exceptions caused by network errors, e.g. if 
server is unavailable. Catch this exceptions so programs will be able to 
continue work.

Make all creating and deleting methods of JSON API a POST requests.

Currently communication with CouchDB is done via it's general Python bingdings 
or direct HTTP. It is requires to develop a common database model-specific 
interface that will represent simulation and model entities: project, job, etc.

Live view animation not properly closed and continues after closing.

Store start time of task in scheduler.

Now if there are several nodes running at one computer they will use one log 
file. Make some mechanism to provide this settings to nodes individually.

When adding task in scheduler scheck whether it dublicates something that is 
already in queue or in progress.

Currently cars accelerate instantly. Implement realistic change of speed.

Implement oncomming traffic in model

Make a worker a constantly running daemon process which periodically schecks 
for tasks on scheduler and runs them.

In webui.py separate JSON-RPC logic from handler logic. Develop something like 
SimpleXMLRPCServer.

May be using job IDs (numbers) instead if names (strings) can improve speed and 
minimize traffic.

Road intersection with two directions: forward and right.

Remember table sorting when new table is redrawn.

Show job stats in a web interface.

Now if web interface couldn't get update of status from API server it does 
nothing. Show some message to the user.

Define worker task types in configuration.

In current nodejs scheduler there is no mention of providing worker 
notification interval.
 * Change specification
 * Implement specification on scheduler: get time from config.
 * fix regression on worker.

Import data simulated in offline worker into database via WebUI.

Collect information about simulation network, such as where and which 
components are started.

Perform basic statistic calculations in worker.

If job has been deleted while simulation - work correctly.

Fully implement traffic intersection.

Buttons to control playing of live view:
  * play
  * pause
  * speed up
  * speed down
  * next step (on pause)
  * previous step (on pause)
  * stop

Implement overtaking of cars in model. Car can overtake if there is a safe 
distance in front and at rear of it target position. Also front distance must 
be greater than current. And current speed must be lower than desired speed.

Store some stats about workers and how they execute simulation tasks.
For example:
 * how many tasks simulated.
 * how many states simulated
 * how much time it required

Extract common code of logger initialization to separate function in common 
library. This function will take as a argument ConfigParser with [log] section 
with configuration data and will return a logger instance.

Show job stats in a web interface.

In a web interface show stats in a progress counter (somehow).

Run RPC server at each node with it's infrastructure and create communication 
network between schedulers.

Create supervisor process that will control jobs progress and restart jobs 
which workers are not responding at time.

Create WebUI for scheduler: currently use same as on python. Then remove 
current http api.

Try Dojo table.

Base class for all model objects with methods:
  * frontPosition
  * backPosition
  * state: active or not

Nodejs scheduler provides list of databases, use it in the worker.

Implement Scheduler-Worker protocol v0.1 at a worker side.
  * getJob
  * reportStatus
  * reportStatus according to timeout timer.