xpflow 0.1b

data/lib/xpflow/runtime.rb

@@ -0,0 +1,125 @@
+
+# some runtime related
+# activities
+
+module XPFlow
+
+    # TODO
+    # I have to decide what is a model of an event
+
+    class RuntimeEvent
+
+        attr_reader :type
+        attr_reader :meta
+
+        constructor :type, :meta
+
+        def to_s
+            "<Event: type = #{@type.inspect}, meta = #{@meta.inspect}>"
+        end
+
+    end
+
+    class RuntimeLibrary < MonitoredActivityLibrary
+
+        activities :activities,
+            :run_group, :show_gantt, :save_gantt,
+            :start, :finish, :event, :dump_events, :events,
+            :list_checkpoints,
+            :list => :activities
+
+        def setup
+            @events = []
+        end
+
+        def checkpoint
+            return @events
+        end
+
+        def restore(state)
+            @events = state
+        end
+
+        # these are routed as well from stdlib.rb
+        def event(type, meta = {})
+            ev = RuntimeEvent.new(type, {}.merge(meta))
+            @events.push(ev)
+        end
+
+        def start(name, meta = {})
+            event(:start, meta.merge({ :name => name }))
+        end
+
+        def finish(name, meta = {})
+            event(:finish, meta.merge({ :name => name }))
+        end
+
+        def dump_events
+            # debug activity
+            pp @events
+        end
+
+        def events(type = nil, &block)
+            if type.nil?
+                events = @events
+            else
+                events = @events.select { |e| ev.type == type }
+            end
+            events = events.select(&block) if block_given?
+            return events.dup
+        end
+
+        def activities
+            puts "List of activities:"
+            ns = proxy.engine.get_global_namespace()
+            lines = ns.map { |k, v| "   * #{v.info}" }.sort
+            puts lines.join("\n")
+        end
+
+        def self.save_workflow(filename, engine, name)
+            p = engine.get_activity_object(name)
+            ns = name.to_s.split(".")[0...-1]
+            opts = { :engine => engine }
+            flow = Graphing::XPFlowConverter.from_process(p, ns, opts)
+
+            ext = File.extname(filename).downcase
+
+            ropts = { :debug => false }
+            case ext
+                when '.tikz' then Graphing.to_tikz(flow, filename, ropts)
+                when '.pdf' then Graphing.to_pdf(flow, filename, ropts)
+                when '.png' then Graphing.to_png(flow, filename, ropts)
+                when '.tex' then Graphing.to_latex(flow, filename, ropts)
+                else
+                    raise "Unsupported format '#{ext}'."
+            end
+
+            puts "Workflow of '#{name.to_s.green}' process saved to '#{filename.green}'."
+            puts "Check out '#{"tikz_template.tex".green}' template in examples directory." if ext == '.tikz'
+        end
+
+        def run_group(infos)
+            infos.each do |i|
+                proxy.run i.name, *i.args
+            end
+        end
+
+        def list_checkpoints
+            cps = proxy.engine.dumper.list
+            puts "List of checkpoints:"
+            cps.each_pair do |k, v|
+                puts "    #{k} => #{v.first['time_string']}"
+            end
+        end
+
+        def show_gantt
+            Visual.show_gantt(events())
+        end
+
+        def save_gantt(filename)
+            Visual.save_gantt(filename, events())
+        end
+
+    end
+
+end

data/lib/xpflow/scope.rb

@@ -0,0 +1,168 @@
+
+require 'thread'
+
+module XPFlow
+
+    $scope_mutex = Mutex.new
+    $scope_cv = ConditionVariable.new
+
+    class Scope
+
+        constructor :parent, :vars => { }
+
+        attr_reader :parent
+        attr_reader :vars
+
+        def push
+            return Scope.new(self)
+        end
+
+        def vars
+            return @vars
+        end
+
+        def [](key)
+            return get(key)
+        end
+
+        def get(key, return_nil = false)
+            found = false
+            val = nil
+            $scope_mutex.synchronize do
+                while true
+                    found, val = try_get(key)
+                    break if (found or return_nil)
+                    $scope_cv.wait($scope_mutex)
+                end
+            end
+            return val
+        end
+
+        def get_now(key, default = nil)
+            v = get(key, true)
+            return (v.nil?) ? default : v
+        end
+
+        def []=(key, value)
+            $scope_mutex.synchronize do
+                @vars[key] = value
+                $scope_cv.broadcast
+            end
+        end
+
+        def merge!(hash)
+            $scope_mutex.synchronize do
+                @vars.merge!(hash)
+                $scope_cv.broadcast
+            end
+        end
+
+        # do not use methods below!
+
+        def try_get(key)
+            curr = self
+            found = false
+            val = nil
+            while (not found) and (not curr.nil?)
+                found, val = curr.query(key)
+                curr = curr.parent
+            end
+            return [ found, val ]
+        end
+
+        def query(key)
+            return [ @vars.key?(key), @vars[key] ]
+        end
+
+        def to_s
+            @vars.inspect + @parent.to_s
+        end
+
+        def to_a
+            arr = [ @vars ]
+            arr += @parent.to_a unless @parent.nil?
+            return arr
+        end
+
+        def to_keys
+            return to_a.map(&:keys)
+        end
+
+        def containing(key)
+            if @vars.key?(key)
+                return self
+            else
+                return @parent.containing(key)
+            end
+        end
+
+        def current_activity(levels = 1)
+            this = Scope.current
+            while levels > 0 
+                if this.vars.key?(:__activity__)
+                    levels -= 1
+                end
+                break if levels == 0
+                this = this.parent
+            end
+            return this
+        end
+
+        def parent_activity
+            return current_activity(2)
+        end
+
+        def engine
+            value = get(:__engine__, nil)
+            raise "No engine!" if value.nil?
+            return value
+        end
+
+        def experiment
+            value = get(:__experiment__, nil)
+            raise "No experiment!" if value.nil?
+            return value
+        end
+
+        # static methods
+        # it's okay to use them
+
+        def self.reset()
+            Scope.set(Scope.new(nil))
+        end
+
+        def self.set(scope, hash = {})
+            Thread.current[:__scope__] = scope 
+            scope.merge!(hash)
+        end
+
+        def self.current()
+            return Thread.current[:__scope__]
+        end
+
+        def self.engine()
+            return current().engine
+        end
+
+        def self.push()
+            return current().push
+        end
+
+        def self.region(&block)
+            previous = self.current()
+            result = nil
+            begin
+                new_scope = previous.push()
+                Scope.set(new_scope)
+                result = block.call(new_scope)
+            ensure
+                Scope.set(previous)
+            end
+            return result
+        end
+
+    end
+
+    Scope.reset()  # initialize the global scope
+
+end

data/lib/xpflow/ssh.rb

@@ -0,0 +1,186 @@
+# encoding: UTF-8
+
+#
+# Extensions to NetSSH library.
+#  * implementation of transparent connection tunneling (Net::SSH.tunnel)
+#
+
+module Net; module SSH; module Service
+
+    class LoopThread
+
+        def initialize
+            @lock = Mutex.new
+            @active = true
+            @t = Thread.new do
+                yield Proc.new { active? }
+            end
+        end
+
+        def active?
+            @lock.synchronize do
+                @active
+            end
+        end
+
+        def join
+            @lock.synchronize do
+                @active = false
+            end
+            @t.join
+        end
+
+    end
+
+    # additional forwarding methods
+    class Forward
+
+        def direct(socket, host, port)
+
+            debug { "direct-redirect on #{socket}" }
+
+            channel = session.open_channel("direct-tcpip", :string, host, :long, 
+                port, :string, "127.0.0.1", :long, 22334) do |ch|
+                ch.info { "Channel established" }
+            end
+
+            prepare_client(socket, channel, :local)
+
+            channel.on_open_failed do |ch, code, desc|
+                channel.error { "error: #{desc} (#{code})" }
+                channel[:socket].close
+            end
+        end
+
+        def connect(host, port)
+            # in Ruby 1.9, one can write: Socket.pair(:UNIX, :STREAM, 0)
+            client, server = Socket.pair('AF_UNIX', 'SOCK_STREAM', 0)
+            direct(server, host, port)
+            return client
+        end
+
+        def ssh(host, user, options = {})
+            port = options.fetch(:port, 22)
+            fd = connect(host, port)
+            class << fd
+                def peer_ip
+                    "<faked IP>"
+                end
+            end
+            t = LoopThread.new do |active|
+                session.loop(0.1) do
+                    active.call
+                end
+            end
+            options[:proxy] = FakeFactory.new(fd)
+            begin
+                s = Net::SSH.start(host, user, options)
+            rescue
+                t.join   # stop the thread
+                raise
+            end
+            class << s
+                attr_accessor :loop_thread
+                alias old_close close
+
+                def close
+                    old_close  # let this socket to close
+                    loop_thread.join   # abandon upper loop
+                end
+            end
+            s.loop_thread = t
+
+            if block_given?
+                begin
+                    yield s
+                ensure
+                    s.close
+                end
+            else
+                return s
+            end
+        end
+
+    end
+
+    class FakeFactory
+        
+        def initialize(socket)
+            @socket = socket
+        end
+
+        def open(*args)
+            return @socket
+        end
+    end
+
+end; end; end
+
+module Net; module SSH
+
+    class SSHLogin
+        
+        attr_reader :user
+        attr_reader :host
+        attr_reader :port
+
+        def initialize(spec)
+            @user, @host, @port = parse(spec)
+        end
+
+        def parse(spec)
+            m = /(?:(.+)@)?(.+?)(?::(\d+))?$/.match(spec)
+            raise 'wrong login specification' if m.nil?
+            user, host, port = m.captures
+            port = 22 if port.nil?
+            user = Etc.getlogin if user.nil?
+            return [user, host, port.to_i]
+        end
+
+    end
+
+    def self.tunnel(hosts, opts = {})
+        hosts = hosts.map { |h| SSHLogin.new(h) }
+
+        hops = []
+        begin
+            proxy = hosts.first
+            opts[:port] = proxy.port
+            hops.push(Net::SSH.start(proxy.host, proxy.user, opts))
+            for node in hosts[1..-1] do
+                opts[:port] = node.port
+                next_hop = hops.last.forward.ssh(node.host, node.user, opts)
+                hops.push(next_hop)
+            end
+        rescue
+            while hops.length != 0 do
+                hops.pop.close
+            end
+            raise
+        end
+
+        session = hops.last
+        class << session
+            alias older_close close
+            attr_accessor :masters
+            def close
+                older_close
+                while masters.length != 0 do
+                    masters.pop.close
+                end
+            end
+        end
+        session.masters = hops[0...-1]
+
+        if block_given?
+            begin
+                return(yield session)
+            ensure
+                session.close
+            end
+        else
+            return session
+        end
+    end
+
+end; end

data/lib/xpflow/stat.rb

@@ -0,0 +1,50 @@
+#Credit for cdf_inverse : http://home.online.no/~pjacklam/notes/invnorm/
+#
+module NormalDistribution
+  # inverse standard normal cumulative distribution function
+  def cdf_inverse(p)
+    a = [0, -3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, 1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00]
+    b = [0, -5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, 6.680131188771972e+01, -1.328068155288572e+01]
+    c = [0, -7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00]
+    d = [0, 7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00]
+    #Define break-points.
+    p_low  = 0.02425
+    p_high = 1.0 - p_low
+
+    x = 0.0
+    q = 0.0
+    #Rational approximation for lower region.
+    if 0.0 < p && p < p_low
+      q = Math.sqrt(-2.0*Math.log(p))
+      x = (((((c[1]*q+c[2])*q+c[3])*q+c[4])*q+c[5])*q+c[6]) / ((((d[1]*q+d[2])*q+d[3])*q+d[4])*q+1.0)
+
+    #Rational approximation for central region.
+    elsif p_low <= p && p <= p_high
+      q = p - 0.5
+      r = q*q
+      x = (((((a[1]*r+a[2])*r+a[3])*r+a[4])*r+a[5])*r+a[6])*q / (((((b[1]*r+b[2])*r+b[3])*r+b[4])*r+b[5])*r+1.0)
+
+    #Rational approximation for upper region.
+    elsif p_high < p && p < 1.0
+      q = Math.sqrt(-2.0*Math.log(1.0-p))
+      x = -(((((c[1]*q+c[2])*q+c[3])*q+c[4])*q+c[5])*q+c[6]) / ((((d[1]*q+d[2])*q+d[3])*q+d[4])*q+1.0)
+    end
+
+    #The relative error of the approximation has
+    #absolute value less than 1.15 × 10−9.  One iteration of
+    #Halley’s rational method (third order) gives full machine precision.
+    if 0 < p && p < 1
+      e = 0.5 * Math.erfc(-x/Math.sqrt(2.0)) - p
+      u = e * Math.sqrt(2.0*Math::PI) * Math.exp((x**2.0)/2.0)
+      x = x - u/(1.0 + x*u/2.0)
+    end
+    x
+  end
+  #vectors is values and prec and confidence is in percentage
+  def estimate_samples(rel,vector,precision,confidance)
+    avg=vector.average
+    real_prec=avg*precision if rel
+    critical_value=cdf_inverce((1-confidance)/2)
+    ((critical_value*vector.stddev / real_prec) ** 2).to_i + 1
+  end
+end