laborantin 0.0.14 → 0.0.21

data/INFO

@@ -0,0 +1 @@
+could not determine sha1 at packaging time

data/README

@@ -1,5 +1,149 @@
-Laborantin is a measurement batch facilitator.
-When you need to perform a lot of measurements varying some parameters, Laborantin helps you to stay organized.
-It provides an abstraction of environments and scenarii, vary all possible parameters and store everything in directories.
+= Laborantin (cheaper than an intern!)
+
+
+== Purpose
+
+Laborantin is a framework intended to help people that performs a lot of experiments that can be scripted (e.g., scientists).
+It has two main abstractions: Environment and Scenario.
+* Environment: represents what cannot be changed easily, like the version of an operating system, or an hardware component.
+* Scenario: represents an experiment, with parameters that you will vary to study their impact.
+
+Laborantin ships with an executable script that allows you to perform recurring tasks like running, finding experiments with filtering on parameters sets.
+The experiments reports are stored in a directory structure such that you don't have to bother about where to store which paramters.
+Environments and Scenarios are also accessible as regular libraries (unless you don't want to use Ruby at all), such that you can use all the stored data without too much efforts.
+
+=== Benefits
+
+Laborantin enables you to focus on your experiments and not on the silly issues that come with scientific rigor, like logging what happened, organizing your scripts, or writing an argument parser for the N-th time.
+
+=== Current Features
+
+* library with
+  * handy logging
+  * hook points before/after experiments
+  * easy selection of experiments for post-analysis 
+* command line interface
+  * to run, retrieve, destroy, analyze experiments
+  * easily extendable (e.g. for HTML reporting)
+
+=== Next Improvements
+
+* verify that we're actually in a laborantin directory
+* run identifier
+* per-scenario logfile
+* inherit from parameters, products and hooks
+* better analysis meta-data for automated reporting
+* better Git integration
+* better use of the configurations
+
+=== Future
+
+The future of Laborantin mainly depends on you, what are your needs? can you patch it?
+We envision four main branches for the future of Laborantin:
+* *Develop* a way for everyone to define its prefered directory structure, especially heretics that do not want to use Ruby and Laborantin's libraries to read the experiments reports.
+* *Develop* roles in experiments having each Laborantin be a cooperating agent (maybe a P2P one).
+
+Also, Laborantin was written super quickly, and there certainly is room for a lot of code and design improvements, feel free to participate (see contacts below).
+== Workflow
+
+Working with Laborantin is not straightforward, but it's not too much of a pain neither. You can follow the tutorial (http://dicioccio.fr/laborantin) if you want the short overview on how to use it.
+
+=== The labor script commands
+
+==== help
+Simply shows a list of available commands, if an argument is passed, details the command.
+
+- <tt>labor help</tt>
+- <tt>labor create --help</tt>
+
+==== create
+Initializes a workbench with the correct directory structure. You can directly create empty stub files for environments and scenarii if you know what you will do.
+
+- <tt>labor create workbench [--envs=foo1,foo2] [-s bar1]</tt>
+
+==== describe
+Describes a workbench Environments and Scenarii, that's why it's important to fill the descriptions.
+
+- <tt>labor describe</tt>
+
+==== run
+Runs matching -e Environments and -s Scenarii experiments, with parameters given in -p. With the -c flag, you can set it to skip experiments which already have a successful record in the database.
+
+- <tt>labor run [-e foo] [-p "{:bar => [1,2,3]}"] [-s bar1]</tt>
+
+==== scan
+Scans the result directory and counts, for each Scenario and Environment class, the number of performed instances.
+
+- <tt>labor scan</tt>
+
+==== find
+Finds in the result dir the performed instances, and prints their name. The --successful or --failed flags allow you to display only the experiments that went right.
+
+- <tt>labor find [-p "{:foo => [1,2,3]}"]</tt>
+
+==== replay
+Produces the scenario's product for scenarios that matching the -e, -s, and -p options (like in the run command).
+
+- <tt>labor replay [-s foo,bar] [-p "{:baz => [1,2,3]}"]</tt>
+- <tt>labor replay [-m meth1,meth2]</tt>
+
+==== analyze
+Analyses the result to produce what you want (e.g., a plot). The -a option allows you to select only a subset of the analyses.
+- <tt>labor analyze [-a foo,bar]</tt>
+
+==== rm
+Removes the result from the database, the syntax is very similar to labor find. Simply: what would be printed on the screen with the find command will be destroyed. 
+
+==== note
+Adds a record to the BOOKNOTE file, its only purpose is for you to keep track of oddities, bugs, or ideas during the long process of doing experimentations.
+
+==== config set|get|del
+Currently unused, will serve later.
+
+=== Typical workflow
+
+==== Ideal world
+The following list lacks many details, hopefully I'll find time to write more doc.
+
+* create a project directory with <tt>labor create <name></tt>.
+* cd <name>
+* edit ./environments/<env>
+* edit ./scenarii/<scenario> (NB: the "run method in your scenarios must take at least 1sec., sleep if necessary")
+* verify that things seems correct with <tt>labor describe</tt>
+* run things with <tt>labor run</tt>   (and wait a bit)
+* ensure that we have the results we need with <tt>labor scan</tt>
+* produces per-scenario intermediary results with <tt>labor replay</tt>
+* edit ./analyses/<analysis>
+* analyse your results with <tt>labor analyze</tt>
+
+Moreover, at any point, you can take notes with <tt>labor note "some note"</tt>.
+
+==== Real (cursed) world
+Often, experiments crash. Sometimes, you are bothered by the presence of an old result which forces you to add filter to the command line. 
+
+Since last version, Laborantin provides support to handle these cases:
+
+Let's say you had a crash during a run of 1000 experiments. <tt>labor scan</tt> will show that you only completed 200 of them. The thing is that you have a lot of parameters, and little time to figure-out which combinations of parameters are missing. Your Laborantin will do that for you, just re-run the same command that crashed (after fixing the source of the bug), and append it the -c option, and it will re-run only what crashed or is missing.
+
+Then if you're not interested in the failed results, you can use <tt>labor rm --failed</tt>.
+
+== Hints
+
+=== Super classes ?
+You can benefit from object orientation of Scenarii both in Environment and Scenarii, just make sure you don't run them (for Environment, set a dummy verification which is always false).
+
+Unfortunately, subclasses of Environment or Scenario do not automatically inheritates from parent's parameter/products/setup/teardown information.
+
+=== Environment or Scenario ?
+Sometimes it is hard to know what should go inside the code of the Environment and what should go inside the code of the Scenario. Indeed, you can compare two environments like you would compare two scenariis. There is no rule that fits all purposes, but I suggest that what can be changed easily should go to the environment. Also, all code which is related to sending commands to distant computers fit well in environments. Meanwhile, the content of the command is build inside the scenario.
+
+=== Parameter or not ?
+The same kind of ambivalence exists between Parameters and Scenarii. Sometimes the design of the same scenario with a different parameter makes more sense with a subclass (when you start having a lot of  `if params[:foo] == :bar'. It's up to you to decide afterwards, how you'll be filtering on results and perform your analysis.
+
+== Contributors / Contacts
+
+* Lucas Di Cioccio (http://dicioccio.fr)
+
+== Licence
+This library and tools are licensed under the GPL version 3 (http://www.gnu.org/licenses).
 
-Next, it will ease the reprocessing of measurements, synchronization to send reports to a backup server, and maybe provide some coordination with distant nodes.

data/Rakefile

@@ -1,46 +1,92 @@
 require 'rubygems'
 require 'rake/gempackagetask'
 
+$LOAD_PATH.unshift('lib')
+require 'lib/laborantin'
+
 spec = Gem::Specification.new do |s|
+
         s.name = 'laborantin'
-        s.version = '0.0.14'
-        s.platform = Gem::Platform::RUBY
+        s.rubyforge_project = 'laborantin'
+        s.version = Laborantin::VERSION
+        s.author = Laborantin::AUTHORS.first
+        s.homepage = Laborantin::WEBSITE
         s.summary = "A measurement batch facilitator"
-
-        s.author = "Di Cioccio Lucas"
         s.email = "lucas.dicioccio<@nospam@>frihd.net"
-        s.rubyforge_project = 'laborantin'
-        s.homepage = 'http://rubyforge.org/projects/laborantin'
-
-        s.files = ['README', 'LICENSE', 'gpl-3.0.txt',
-	       	'Rakefile', 'TODO', 
-		'bin/labor',
-		'bin/files/README.erb',
-		'bin/files/TODO.erb',
-		'bin/files/config/ftp.yaml.erb',
-		'bin/files/config/xmpp.yaml.erb',
-		'bin/files/environments/environment.rb.erb',
-		'bin/files/scenarii/scenario.rb.erb',
-		'lib/laborantin.rb',
-		'lib/laborantin/core/environment.rb',
-		'lib/laborantin/core/parameter.rb',
-		'lib/laborantin/core/parameter_hash.rb',
-		'lib/laborantin/core/scenario.rb',
-		'lib/laborantin/core/monkey_patches.rb',
-	]
+        s.platform = Gem::Platform::RUBY
 
-        s.require_path = 'lib'
-	s.bindir = 'bin'
-	s.executables = ['labor']
+        s.files = [
+          'README',
+          'LICENSE', 
+          'gpl-3.0.txt',
+          'Rakefile', 
+          'TODO', 
+          'INFO',
+          'bin/labor',
+          'lib/laborantin.rb',
+          'lib/laborantin/core/environment.rb',
+          'lib/laborantin/core/parameter.rb',
+          'lib/laborantin/core/parameter_hash.rb',
+          'lib/laborantin/core/scenario.rb',
+          'lib/laborantin/core/monkey_patches.rb',
+          'lib/laborantin/core/analysis.rb',
+          'lib/laborantin/core/command.rb',
+          'lib/laborantin/core/datable.rb',
+          'lib/laborantin/core/completeable.rb',
+          'lib/laborantin/core/describable.rb',
+          'lib/laborantin/core/hookable.rb',
+          'lib/laborantin/core/configurable.rb',
+          'lib/laborantin/core/multi_name.rb',
+          'lib/laborantin/core/table.rb',
+          'lib/laborantin/runner.rb',
+          'lib/laborantin/runner/commands/complete.rb',
+          'lib/laborantin/runner/commands/create.rb',
+          'lib/laborantin/runner/commands/describe.rb',
+          'lib/laborantin/runner/commands/run.rb',
+          'lib/laborantin/runner/commands/analyze.rb',
+          'lib/laborantin/runner/commands/load_classes.rb',
+          'lib/laborantin/runner/commands/load_results.rb',
+          'lib/laborantin/runner/commands/replay.rb',
+          'lib/laborantin/runner/commands/find.rb',
+          'lib/laborantin/runner/commands/scan.rb',
+          'lib/laborantin/runner/commands/note.rb',
+          'lib/laborantin/runner/commands/cleanup.rb',
+          'lib/laborantin/runner/commands/rm.rb',
+          'lib/laborantin/runner/commands/config.rb',
+          'lib/laborantin/extra/commands/git.rb',
+          'lib/laborantin/extra/commands/git/check.rb',
+          'lib/laborantin/extra/commands/git/run.rb',
+          'lib/laborantin/extra/vectorial_product.rb'
+        ]
 
+        s.require_path = 'lib'
+        s.bindir = 'bin'
+        s.executables = ['labor']
         s.has_rdoc = true
 end
 
+file 'INFO' => spec.files - ['INFO'] do
+  print "trying to gather source revision for build ... "
+  File.open('INFO', 'w') do |f|
+    begin
+      require 'git'
+      g = Git.open('.')
+      sha1 = g.revparse(g.current_branch)
+      f.puts sha1
+      puts "OK"
+    rescue Exception => err
+      puts "KO (not fatal)"
+      f.puts "could not determine sha1 at packaging time"
+      puts "#{err}"
+    end
+  end
+end
+
 Rake::GemPackageTask.new(spec) do |pkg|
         pkg.need_tar = true
 end
 
-task :gem => "pkg/#{spec.name}-#{spec.version}.gem" do
+task :gem => ["pkg/#{spec.name}-#{spec.version}.gem", 'INFO'] do
         puts "generated #{spec.version}"
 end
 

data/TODO

@@ -1,6 +1,27 @@
-replay / pause / restart
-
-=> interaction with rubydrill?
-=> or direct stats
-
-creation of a script that doesn't depends on laborantin for export?
+new data structure:
+  in config files (both env and scenarii):
+    reference every rundir
+    reference the class type
+    reference the success/failure status (not in scenarii for now)
+    reference the date (not in env for now, badly done for scenarii)
+  reference the laborantin version somewhere
+  relax 1sec constraint for uniqueness with an ID field instead
+  make such that load / save methods pass through an adapter (database)
+  migrate command that will take a legacy dir and make a new one from it by loading the old way; fixing the data model; saving in the new way
+commands:
+	report 
+	publish
+  migrate (from version to version, and dir structure to dir structure)
+  check (a sort of run but that you can abbreviate, 
+    and that writes in a tempdir)
+  optimize (given a goal)
+  estimate (cost, duration, 
+    whatever defined by the user, only total sum, products?)
+  infos (gives info about the running environment)
+config dir:
+	extra libraries to require
+general:
+	move runner into core/ and cli_runner into base/
+	move runner/commands in another directory (e.g. /commands or /base/commands or /core/commands)
+	roles for multi-machines
+  git integration (from create to everything)

data/bin/labor

@@ -1,408 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
 require 'laborantin'
-#require '../lib/laborantin'
-require	'optparse'
-require	'fileutils'
-require 'find'
-require 'erb'
-require	'yaml'
-require 'net/ftp'
-require 'logger'
+require 'laborantin/runner'
 
-class Command
-  attr_accessor :name, :description, :parser, :block, :options, :args
-
-  @@all = []
-
-  def find_and_require(dir, filter=[])
-    Find.find(dir) do |f|
-      test = if filter.empty?
-               File.extname(f) == '.rb'
-             else
-               filter.include? File.basename(f)
-             end
-      require f if test
-    end
-  end
-
-  def initialize(name, description='')
-    @@all << self
-    @name = name
-    @description = description
-    @options = {}
-    @args = []
-    yield self
-  end
-
-  def self.all
-    @@all
-  end
-
-  def self.for_name(name)
-    @@all.find{|c| c.name == name}
-  end
-
-  def opts(&argblk)
-    @parser =  OptionParser.new &argblk
-    script_name = File.basename($0)
-    @parser.summary_indent = "\t"
-    @parser.banner = %{Usage: #{script_name} #{name} [OPTIONS] [env1 [env2 ..]]}
-    @parser.banner << %{\n#{description}} unless description.empty?
-  end
-
-  def parse!(args)
-    begin
-      @args = @parser.parse args
-    rescue OptionParser::InvalidOption => err
-      puts err
-      puts @parser
-      exit
-    end
-  end
-
-  def execute(&blk)
-    @block = blk
-  end
-
-  def execute!
-    self.instance_eval &@block if @block
-  end
-end
-
-# Create
-
-Command.new('create', 'prepares a dir for laborantin measurements') do |c|
-  c.options[:scenarii] = []
-  c.options[:environments] = []
-  c.options[:force] = false
-  c.opts do |o|
-    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|val| c.options[:scenarii] = val}
-    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|val| c.options[:environments] = val}
-    o.on_tail('-f', '--force', 'force overwrite') {|val| c.options[:force] = val}
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-
-  c.execute do 
-    dir = args.shift
-    p dir #not for debug
-    unless c.options[:force]
-      begin
-        FileUtils.mkdir dir
-      rescue Errno::EEXIST => err
-        puts "Directory already exists, use -f/--force to overwrite (will overwrite all generated files, use at your own risk)."
-        exit 
-      end
-    end
-    %w{environments scenarii results config scripts}.each do |w|
-      path = File.join( dir, w )
-      p path #not for debug
-      FileUtils.mkdir_p path
-    end
-    %w{README TODO config/ftp.yaml config/xmpp.yaml}.each do |w|
-      res_path = File.join(dir, w)
-      p res_path #not for debug
-      File.open(res_path, 'w') do |f|
-        tpl = ''
-        tpl_path = (File.join(File.dirname(__FILE__), 'files', "#{w}.erb"))
-        File.open(tpl_path) do |tf|
-          tpl = tf.read
-        end
-        erb = ERB.new tpl
-        erb.filename = res_path
-        f.puts erb.result(binding)
-      end
-    end
-    @options[:scenarii].each do |s|
-      res_path = File.join(dir, 'scenarii', "#{s}.rb")
-      p res_path #not for debug
-      File.open(res_path, 'w') do |f|
-        tpl = ''
-        tpl_path = (File.join(File.dirname(__FILE__), 'files', 'scenarii', 'scenario.rb.erb'))
-        File.open(tpl_path) do |tf|
-          tpl = tf.read
-        end
-        erb = ERB.new tpl
-        erb.filename = res_path
-        f.puts erb.result(binding)
-      end
-    end
-    @options[:environments].each do |e|
-      res_path = File.join(dir, 'environments', "#{e}.rb")
-      p res_path #not for debug
-      File.open(res_path, 'w') do |f|
-        tpl = ''
-        tpl_path = (File.join(File.dirname(__FILE__), 'files', 'environments', 'environment.rb.erb'))
-        File.open(tpl_path) do |tf|
-          tpl = tf.read
-        end
-        erb = ERB.new tpl
-        erb.filename = res_path
-        f.puts erb.result(binding)
-      end
-    end
-  end
-end
-
-# Describe
-
-Command.new('describe', "describes a laborantin's work") do |c|
-  c.options[:environments] = []
-  c.options[:scenarii] = []
-  c.opts do |o|
-    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|val| c.options[:scenarii] = val}
-    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|val| c.options[:environments] = val}
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-  c.execute do
-    FileUtils.cd(args.first || '.')
-    loaded_envs = c.options[:environments].map{|e| "#{e}.rb"}
-    loaded_scii = c.options[:scenarii].map{|e| "#{e}.rb"}
-    find_and_require('environments', loaded_envs)
-    find_and_require('scenarii', loaded_scii)
-
-    Laborantin::Environment.all.each {|e| p e}
-    Laborantin::Scenario.all.each {|s| p s}
-  end
-end
-
-# Scan
-
-Command.new('scan', "scan a laborantin's dir for results") do |c|
-  c.options[:filter] = ''
-  c.options[:environments] = []
-  c.options[:scenarii] = []
-  c.opts do |o|
-    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|val| c.options[:scenarii] = val}
-    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|val| c.options[:environments] = val}
-    o.on('-p', '--parameters=OPTIONAL', 'filter parameters (ruby hash format)', String) {|val| c.options[:filter] = val}
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-  c.execute do
-    FileUtils.cd(args.first || '.')
-    loaded_envs = c.options[:environments].map{|e| "#{e}.rb"}
-    loaded_scii = c.options[:scenarii].map{|e| "#{e}.rb"}
-    find_and_require('environments', loaded_envs)
-    find_and_require('scenarii', loaded_scii)
-
-    envs = Laborantin::Environment.scan_resdir('results')
-
-    scs = envs.map{|env| env.populate }.flatten
-
-    puts "Laborantin' summary:"
-    Laborantin::Environment.all.each do |envklass|
-      puts "#{envklass.name.duck_case} => #{envs.count{|e| e.is_a? envklass}}"
-      Laborantin::Scenario.all.each do |scklass|
-        puts "\t#{scklass.name.duck_case} => #{scs.count{|s| s.is_a? scklass and s.environment.is_a? envklass}}"
-      end
-    end
-
-  end
-end
-
-# Find
-
-Command.new('find', "find the results dir for a set of params/env") do |c|
-  c.options[:filter] = ''
-  c.options[:environments] = []
-  c.options[:scenarii] = []
-  c.opts do |o|
-    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|val| c.options[:scenarii] = val}
-    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|val| c.options[:environments] = val}
-    o.on('-p', '--parameters=OPTIONAL', 'filter parameters (ruby hash format)', String) {|val| c.options[:filter] = val}
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-  c.execute do
-
-    FileUtils.cd(args.first || '.')
-    loaded_envs = c.options[:environments].map{|e| "#{e}.rb"}
-    loaded_scii = c.options[:scenarii].map{|e| "#{e}.rb"}
-    find_and_require('environments', loaded_envs)
-    find_and_require('scenarii', loaded_scii)
-    
-    envs = Laborantin::Environment.scan_resdir('results')
-
-    params = eval @options[:filter] unless @options[:filter].empty?
-    params.each_key{|k| params[k] = [params[k]].flatten} if params
-    params ||= {}
-
-    scs = envs.map{|env| env.populate }.flatten
-
-    scs.each do |sc|
-	to_filter = params.keys.find{|k| not params[k].include?(sc.params[k])}
-	unless to_filter
-		puts sc.rundir
-		puts sc.params.inspect
-	end
-    end
-  end
-end
-
-# Replay
-
-Command.new('replay', 'scan existing runs, keep their raw results but rebuild all the products') do |c|
-  c.options[:scenarii] = []
-  c.options[:environments] = []
-  c.options[:methods] = []
-  c.options[:filter] = ''
-  c.opts do |o|
-    o.on('-m', '--methods=OPTIONAL', 'list of methods to call, else all the products will, you can provide non products methods as well, so beware the typo', Array) {|val| c.options[:methods] = val}
-    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|val| c.options[:scenarii] = val}
-    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|val| c.options[:environments] = val}
-    o.on('-p', '--parameters=OPTIONAL', 'filter parameters (ruby hash format)', String) {|val| c.options[:filter] = val}
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-  c.execute do
-
-    FileUtils.cd(args.first || '.')
-    loaded_envs = c.options[:environments].map{|e| "#{e}.rb"}
-    loaded_scii = c.options[:scenarii].map{|e| "#{e}.rb"}
-    find_and_require('environments', loaded_envs)
-    find_and_require('scenarii', loaded_scii)
-    
-    envs = Laborantin::Environment.scan_resdir('results')
-    envs.each{|env| env.loggers << Logger.new(STDOUT)}
-
-    params = eval @options[:filter] unless @options[:filter].empty?
-    params.each_key{|k| params[k] = [params[k]].flatten} if params
-    params ||= {}
-
-    scs = envs.map{|env| env.populate }.flatten
-
-    scs.each do |sc|
-	to_filter = params.keys.find{|k| not params[k].include?(sc.params[k])}
-	unless to_filter
-		sc.environment.log "Replaying products #{sc.params.inspect}"
-		if c.options[:methods].empty?
-			sc.analyze!
-		else
-			c.options[:methods].each do |meth|
-				sc.send meth
-			end
-		end
-	end
-    end
-  end
-end
-
-# Run
-
-Command.new('run', 'actually perform measurements') do |c|
-  c.options[:scenarii] = []
-  c.options[:environments] = []
-  c.options[:filter] = ''
-  c.opts do |o|
-    o.on('-s', '--scenarii=OPTIONAL', 'scenarii to build, comma separated', Array) {|val| c.options[:scenarii] = val}
-    o.on('-e', '--environments=OPTIONAL', 'environments to prepare, comma separated', Array) {|val| c.options[:environments] = val}
-    o.on('-p', '--parameters=OPTIONAL', 'filter parameters (ruby hash format)', String) {|val| c.options[:filter] = val}
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-  c.execute do 
-    dir = args.first || '.'
-    FileUtils.cd(dir)
-    Find.find('environments', 'scenarii') do |f|
-      require f if File.extname(f) == '.rb'
-    end
-
-    envs = if c.options[:environments].empty?
-             Laborantin::Environment.all
-           else
-             c.options[:environments].map!{|e| e.camelize}
-             Laborantin::Environment.all.select{|e| c.options[:environments].include? e.name}
-           end
-
-    scii = if c.options[:scenarii].empty?
-             Laborantin::Scenario.all
-           else
-             c.options[:scenarii].map!{|e| e.camelize}
-             Laborantin::Scenario.all.select{|e| c.options[:scenarii].include? e.name}
-           end
-
-    params = eval @options[:filter] unless @options[:filter].empty?
-    params.each_key{|k| params[k] = [params[k]].flatten} if params
-
-    envs.each do |eklass|
-      env = eklass.new
-      if env.valid?
-        env.prepare!
-        env.log "Running matching scenarii", :info #TODO: pass the logging+running in the env
-        scii.each do |sklass|
-          sklass.parameters.merge! params if params
-          env.log sklass.parameters.inspect
-          sklass.parameters.each_config do |cfg|
-            sc = sklass.new(env, cfg)
-            sc.prepare!
-            sc.perform!
-            sc.analyze!
-          end
-        end
-        env.teardown!
-        env.log "Scenarii performed", :info
-      end
-    end
-  end
-end
-
-# Run missing
-# TODO scan existing params + filter
-
-# FTP
-
-Command.new('ftp-up', 'upload results via FTP') do |c|
-  c.opts do |o|
-    o.on_tail('-h', '--help', 'shows this help and exit') {puts o; exit}
-  end
-  c.execute do 
-    dir = args.first || '.'
-    FileUtils.cd(dir)
-    cfg_file = File.join('config', 'ftp.yaml')
-    puts "Reading config file from #{cfg_file}"
-    cfg = YAML.load_file cfg_file
-    if cfg[:enable]
-      #TODO: port
-      #      optimize that
-      ftp = Net::FTP.open(cfg[:host], cfg[:nick], cfg[:pass]) do |ftp|
-        Find.find('results') do |f|
-          if File.directory? f
-            ftp.chdir '/'
-            begin
-              ftp.mkdir f
-            rescue Net::FTPPermError
-            end
-            ftp.chdir f
-          elsif File.file? f
-            begin
-              ftp.putbinaryfile f
-            rescue Net::FTPPermError
-            end
-          end
-        end
-      end #ftp
-    else
-      p "Disabled, please edit #{cfg_file}"
-    end
-  end
-end
-
-# Actually run the commands
-
-cmd = Command.for_name ARGV.first
-
-if cmd
-  cmd.parse!(ARGV.dup[1 .. -1])
-  cmd.execute!
-else
-  if ARGV.empty?
-    puts %{#{$0} v.#{Laborantin::VERSION}: No command given
-
-      Usage: #{$0} <command> [options ...]
-
-      <command> among: #{Command.all.map{|c| c.name}.join(", ")} 
-
-      use #{$0} <command> --help for help on a specific command
-    }
-  else
-    puts "Unknown command #{ARGV.first}. \nKnown commands: #{Command.all.map{|c| c.name}.join(', ')} "
-  end
-end
+Laborantin::CliRunner.instance.run_argv(ARGV)