xpflow 0.1b

data/lib/xpflow/events.rb

@@ -0,0 +1,56 @@
+
+require 'thread'
+
+module XPFlow
+
+    class EventHandler
+
+        def initialize(block)
+            @block = block
+        end
+
+        def run(*args)
+            return @block.call(*args)
+        end
+
+    end
+
+    class EventRouter
+
+        def initialize
+            @mutex = Mutex.new
+            @listeners = Hash.new { |h, key| h[key] = [] }
+        end
+
+        def synchronize(&block)
+            return @mutex.synchronize(&block)
+        end
+
+        def listen(event, &block)
+            synchronize do
+                @listeners[event].push(EventHandler.new(block))
+            end
+        end
+
+        def publish(event, args = [])
+            hs = synchronize do
+                @listeners[event].map { |x| x } # copy
+            end
+            hs.each do |h|
+                h.run(*args)
+            end
+        end
+
+    end
+
+end
+
+
+if __FILE__ == $0
+    r = XPFlow::EventRouter.new
+    r.listen(:complete) do |x|
+        puts "yo! #{x}"
+    end
+    r.publish :cze
+    r.publish :complete, [ 1, 2 ]
+end

data/lib/xpflow/experiment.rb

@@ -0,0 +1,65 @@
+
+module XPFlow
+
+    class Experiment
+
+        attr_reader :results
+
+        def initialize(name, results_path, parent = nil)
+            @name = name
+            @parent = parent
+            @results = Collection.new(results_path)
+            @results.create_path()
+            @log_filename = File.join(results_path, "experiment.log")
+            @log_file = FileLog.new(@log_filename).open()
+        end
+
+        def create_subexperiment(name)
+            new_path = File.join(@results.path, name)
+            return Experiment.new(name, new_path, self)
+        end
+
+        def install
+            return self
+        end
+
+        def log(*msgs)
+            @log_file.log(*msgs)
+            @parent.log(*msgs) unless @parent.nil?
+        end
+
+        def store_execution(execution)
+            # puts execution
+            # here we should store the execution so that it will be solved
+        end
+
+        def store_executions(array)
+            array.each { |x| store_execution(x) }
+        end
+
+    end
+
+    class ExperimentBlackHole
+
+        # a version of Experiment that consumes eveything it is given
+        # used in a testsuite
+
+        def initialize(*args); end
+
+        def create_subexperiment(name)
+            return ExperimentBlackHole.new()
+        end
+
+        def install
+            return self
+        end
+
+        def log(*msgs); end
+
+        def store_execution(x); end
+
+        def store_executions(x); end
+
+    end
+
+end

data/lib/xpflow/exts/facter.rb

@@ -0,0 +1,30 @@
+
+## runs facter after deployment
+
+after_activity :__deployment__ do |nodes|
+    execute_many "apt-get update -y", :idempotent => true
+    execute_many "apt-get install -y facter", :idempotent => true
+    facts = execute_many "facter --yaml", :idempotent => true
+    # TODO: collect the facts later or something
+
+    data = engine.inline_process(facts) do |fs|
+        forall fs do |f|
+            yaml = (stdout_of f)
+            node = (node_of f)
+            value [ node, yaml ]
+        end
+    end
+
+    facter_facts = { }
+    data.each do |node, yaml|
+        puts yaml
+        facts = YAML.load(yaml)
+        facter_facts[node] = facts
+    end
+    run :"__getset__.set", :facter_facts, facter_facts
+end
+
+activity :get_fact do |node, factname|
+    facts = run :"__getset__.get", :facter_facts
+    facts[node][factname.to_s]
+end