libisi 0.3.0

data/lib/libisi/tee.rb

@@ -0,0 +1,296 @@
+# Copyright (C) 2007-2010 Logintas AG Switzerland
+#
+# This file is part of Libisi.
+#
+# Libisi is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libisi is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Libisi.  If not, see <http://www.gnu.org/licenses/>.
+
+class Tee
+  attr_accessor :children
+  
+  def deep_clone(obj)
+    case obj
+    when NilClass
+      obj
+    when Fixnum,Bignum,Float,NilClass,FalseClass,
+	TrueClass,Continuation, Symbol, Rational
+      klone = obj
+    when Hash
+      klone = obj.clone
+      obj.each{|k,v| klone[k] = deep_clone(v)}
+    when Array
+      klone = obj.clone
+      klone.clear
+      obj.each{|v| klone << deep_clone(v)}      
+    else
+      klone = obj.clone
+    end
+    klone.instance_variables.each {|v|
+      klone.instance_variable_set(v,deep_clone(klone.instance_variable_get(v)))
+    }
+    klone
+  end
+
+
+  def initialize(children = [])
+    @children = children
+  end
+
+  def signature(method_id, *arguments, &block)
+    "#{method_id}(#{arguments.map {|a| a.inspect}.join(",")}#{",&block" if block})"
+  end
+
+  def method_missing(method_id, *arguments, &block)
+    if block
+      function_results, block_results = call_child(0, method_id, arguments, block)
+      function_results[0]
+    else
+      $log.debug{"Calling #{signature(method_id, *arguments, &block)} sequentially"}
+      # no block given, we can execute 
+      # methods sequentially
+      result = nil
+      children.each_with_index {|child, index|
+	if index < (children.length-1)
+	  child.send(method_id, *(deep_clone(arguments)))
+	else
+	  result = child.send(method_id, *arguments)
+	end
+      }
+      result
+    end
+  end
+
+  def call_child(child_id, method_id, arguments, block)    
+    raise "child with id #{child_id} does not exist" unless 
+      children[child_id]
+
+    original_arguments = arguments
+    arguments = deep_clone(arguments)
+
+    raise "no block given" unless block
+    signature = signature(method_id, *arguments, &block)
+    $log.debug("Child ##{child_id}: Calling #{signature}")
+
+    vars = []
+    if block.arity > 0
+      block.arity.times {|i| vars.push("a#{i}")}      
+    else
+      (-block.arity - 1).times {|i| vars.push("a#{i}")}      
+      vars.push("*a")
+    end
+    block_text = ""
+    block_text += "proc {|#{vars.join(",")}|\n"
+    if child_id < (children.length-1)
+      block_text += "  call_count += 1\n"
+      block_text += "  function_results, block_results = call_child(child_id + 1, method_id, original_arguments, block) if call_count == 1\n"
+      block_text += "  br = block_results[(call_count-1)]\n"
+      block_text += "  br = deep_clone(br)\n"
+#      block_text += "  p [#{vars.join(",")}]\n"
+      block_text += "  br\n"
+    else
+      $log.debug("Last child, collecting results")
+      # this is the last child
+      # here we must collect all
+      # block results
+      block_text += "  br = block.call(#{vars.join(",")})\n"
+      block_text += "  $log.debug{\"Result of block is: \#\{br.inspect}\"\}\n"
+      block_text += "  block_results << deep_clone(br)\n"
+      block_text += "  call_count += 1\n"
+      block_text += "  br\n"
+    end
+    block_text += "}\n"
+    block_results = []
+    function_results = []
+    call_count = 0
+    new_block = eval(block_text)
+    raise "Not same arity" if new_block.arity != block.arity
+
+    if child_id < (children.length-1)
+      function_results << children[child_id].send(method_id, *(deep_clone(arguments)), &new_block)
+    else
+      function_results << children[child_id].send(method_id, *original_arguments, &new_block)
+    end
+    raise "#{signature} master block execute #{block_results.length - 1} " + 
+      "times child block ##{child_id} #{call_count} times." if 
+      call_count != (block_results.length)
+    [function_results, block_results]
+  end
+end
+
+=begin
+   case @state
+   when 0
+      # first call
+      @state = 1
+      @arguments = arguments
+      @block = block
+
+      master.call(method_id, *arguments, &block)
+      calling master function
+    when 1
+      # recall of other function 
+      # while executing master      
+      @state = 2
+      @second_arguemtns = arguments
+      @second_block = block
+      calling children with arguments
+      # now all children have
+      # same calls, going to state 0
+      # again      
+      method_missing(method_id, *arguments, &block)
+    when 2
+      # ok, this is a child call,
+      # should have the same arguments
+      # as those in state 1
+      raise "Second arguemtns are not equal" unless
+	@second_arguments == @arguments
+    end
+  end
+      
+    
+  def method_missing(method_id, *arguments, &block)
+    if @child_processing_number
+
+    end
+
+    signature = "#{method_id}(#{arguments.map {|a| a.inspect}.join(",")})"
+    $log.debug("Teeing #{signature} to #{children.length} children (#{children.map{|c| "#{c.class.name}(#{c.object_id})"}.join(",")})")
+
+    block_args = []
+    block_result = nil
+    
+    if block
+    end
+
+    # call first child and get arguments and result of the block
+
+    children[1..-1].each_with_index {|child,i|
+      unless i == 0
+	@call_stack.push([method_id, arguments, slave_block])
+      else
+	@child_processing_number = i	
+      end
+      
+      if block
+	master.send(method_id, *arguments, master_block)
+      else
+	master.send(method_id, *arguments)
+      end
+      
+      my_block = if i == 0
+		   #print master_block_text
+		 else
+		   #print slave_block_text
+		 end if block
+      
+      $log.debug("Call##{i} #{signature}")
+      if my_block	
+	child.send(method_id, *arguments, &my_block)
+      else
+	child.send(method_id, *arguments)
+      end
+      $log.debug("The arguments of child #{i} of #{signature} were #{block_args[i].inspect} with result #{block_result.inspect}")
+    }
+  end
+
+  def method_missing_old(method_id, *arguments, &block)
+    $log.debug("Teeing #{method_id} to #{children.length} children (#{children.map{|c| "#{c.class.name}(#{c.object_id})"}.join(",")})")      
+
+    o_args = nil
+    o_res = nil
+    block_result = nil
+     
+    ch = children
+    threads = []
+    block_args = []
+
+    mutex = Mutex.new
+    state = :new
+    def set_state(s)
+      mutex.synchronize {
+	state = s
+      }
+    end
+    
+    get_args_block = nil
+    i = nil
+    if block
+      vars = []
+      if block.arity > 0
+	block.arity.times {|i| vars.push("a#{i}")}      
+      else
+	(-block.arity - 1).times {|i| vars.push("a#{i}")}      
+	vars.push("*a")
+      end
+      block_start = "proc {|#{vars.join(",")}| block_args[i] = [#{vars.join(",")}]"
+      master_proc_text =  block_start + " ; start_lock.unlock ; block_result = yield(#{vars.join(",")})}"
+      slave_proc_text =  block_start + " master_lock.synchronize {} block_result }"
+      master_block = eval(master_block_text)
+      slave_block = eval(slave_block_text)
+    end
+    
+    first = true
+    children.each_with_index {|c,index|
+      threads[index] = Thread.fork(index) { |i|
+
+	master = false
+	mutex.synchronize {
+	  master = true if first
+	  first = false
+	}
+
+ 	if master
+	  # get arguments
+	  # wati until all got their arguments
+	  # call
+	  # return result
+	  # after call
+	else
+	  # before call
+	  # call
+	  # after call
+	end
+	
+
+	my_block = nil
+	start_lock.lock
+	if first
+	  # i am master
+	  first = false
+	  return_lock.lock
+	  my_block = master_block if block
+	else
+	  start_lock.unlock
+	  my_block = slave_block if block
+	end
+	
+	# p [method_id,step_in,block_args,block_result]
+	if my_block
+	  c.send(method_id, *arguments, &get_args_block)
+	  return_lock.unlock
+	else
+	  c.send(method_id, *arguments)
+	  start_lock.unlock
+	  return_lock.unlock
+	end
+      }
+    }
+    threads.each {|th| th.join }
+    
+    # call the block
+    block.call(*block_args[0])
+    
+  end
+end
+   
+=end

data/lib/libisi/ui/base.rb

@@ -0,0 +1,116 @@
+# Copyright (C) 2007-2010 Logintas AG Switzerland
+#
+# This file is part of Libisi.
+#
+# Libisi is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libisi is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Libisi.  If not, see <http://www.gnu.org/licenses/>.
+
+class BaseUI
+
+  def name
+    self.class.name
+  end
+  
+  def not_implemented
+    raise "Not implemented in UI #{self.name}"
+  end
+
+  def bell(options = {}); not_implemented;  end
+  def question_yes_no(text, options = {}); info_non_blocking(text);select([:yes,:no],false, options)[0]; end
+  def question_yes_no_retry(text, options = {}); info_non_blocking(text); select([:yes,:no,:retry],false,options)[0]; end
+  def question(text, options = {}); not_implemented; end
+  def info(text, options = {}); not_impelmented; end
+  def info_non_blocking(text, options = {}); info(text, options); end
+
+  def error(text, options = {})
+    info("/!\\ ERROR: #{text}")
+  end
+  def warn(text, options = {})
+    info("/!\\ WARNING: #{text}")
+  end
+
+  def select(list, multi_select = false, options = {}) ; not_implemented; end 
+  def select_index(list, multi_select = false, &block)
+    select(list, multi_select, {:return_indexes => true}, &block)
+  end
+
+  def colorize(color, options={}); yield; end
+
+  def execute_in_console(command, options = {}); not_implemented; end
+
+  # progress 
+  def progress_bar(text,elements,&block)
+    elements = elements.call if elements.class == Proc
+    
+    raise "Please provide an array if you expect elements for your block." if
+      block.arity == 1 and elements.class == Fixnum
+    
+    if progress_bar_enabled?
+      if block.arity == 1	
+	progress_bar_implementation(text, elements.length) {
+	  index = 0
+	  elements.map {|el|
+	    r = yield(el)
+	    progress(index)
+	    index += 1
+	    r
+	  }
+	}
+      else
+	progress_bar_implementation(text, elements, &block)
+      end      
+    else
+      if block.arity == 1	
+ 	elements.map {|el|
+	  yield(el)
+	}	
+      else
+	yield
+      end     
+    end 
+  end
+  
+  def progress_bar_implementation(text, total, &block); not_implemented if progress_bar_enabled?; end
+  def progress(count);  not_implemented if progress_bar_enabled?; end    
+  def progress_message(message); not_implemented if progress_bar_enabled?; end
+  def progress_inc ; not_implemented if progress_bar_enabled?; end
+
+  def pmsg(action = nil,object = nil)
+    return unless progress_bar_enabled?
+    if action
+      @max_action_withs ||= []
+      @max_action_withs.insert(0,action.to_s.length)
+      @max_action_withs = @max_action_withs[0..5] 
+      action = action.ljust(@max_action_withs.max)
+    end
+    message = [action,object].compact.map {|s| s.to_s}.join(": ")
+    progress_message(message)
+  end
+  def pinc(action = nil, object = nil)
+    return unless progress_bar_enabled?
+    progress_inc
+    pmsg(action, object) if action or object
+  end
+  def enable_progress_bar(val = true)  
+    old_val = @progress
+    @progress = val
+    if block_given?
+      yield
+      @progress = old_val
+    end
+  end
+  def progress_bar_enabled?    
+    @progress
+  end
+
+end

data/lib/libisi/ui/console.rb

@@ -0,0 +1,238 @@
+# Copyright (C) 2007-2010 Logintas AG Switzerland
+#
+# This file is part of Libisi.
+#
+# Libisi is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libisi is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Libisi.  If not, see <http://www.gnu.org/licenses/>.
+
+require "libisi/ui/base.rb"
+class ConsoleUI < BaseUI
+  def bell(options = {})
+    print "\007"
+  end
+  def info(text, options = {})
+    bell
+    print "#{text} [hit ENTER]"
+    STDIN.readline
+  end
+  def info_non_blocking(text, options = {})
+    print("#{text}\n")   
+  end
+  def question(text, options = {})
+    default = nil
+    unless options[:default].nil?
+      default = (options[:default] ? "y" : "n")
+    end    
+    
+    while true
+      case default
+      when "y"
+	print(text + "(Y/n)")
+      when "n"
+	print(text + "(y/N)")
+      else
+	print(text + "(y/n)")
+      end
+      answer = STDIN.readline.to_s.strip.downcase
+      answer = default if answer == ""
+      case answer
+      when "y"
+	return true
+      when "n"
+	return false
+      end
+    end
+  end
+  
+  def password(text)
+    begin
+      print "#{text}: "
+      system "stty -echo"    
+      pw = STDIN.gets.chomp
+      print "\n"
+    ensure
+      system "stty echo"
+    end
+    pw
+  end
+
+  # TEXT UI
+  def select(list, multi_select = false, options = {})
+    texts = []
+    list.each_with_index {|val, index|
+      if block_given?
+	item_text = yield(val)
+      else
+	item_text = val.to_s
+      end
+      if item_text.include?("\n")
+	item_text = item_text.split("\n").map {|l| "  #{l}"}.join("\n")
+      end
+      print "#{index + 1}: #{item_text}\n"
+      texts << item_text
+    }
+
+    ret = nil
+    while ret.nil?
+      begin
+	if multi_select
+	  print "Please make your choice. (Comma seperated list or 'all' for all.)\n"
+	else
+	  print "Please make your choice:"
+	end
+	select = STDIN.readline
+
+	if select.strip == "all" or select.strip == "a"
+	  indexes = (0..(list.length-1)).to_a
+	else
+	  values = select.split(",").map {|s| s.strip}
+
+	  indexes = values.map {|n| n.strip}.map {|sel| sel.to_i - 1}.sort.uniq
+	  indexes = indexes.select {|i| i>=0 }
+
+	  if indexes.length < values.length
+	    indexes = values.map {|s| texts.index(s) }.compact.sort.uniq	   
+	  end
+	  
+	  raise "Not all values could be found!" if indexes.length < values.length	  
+	end
+	ret = indexes.map {|sel|
+	  raise "Unexpected input, please enter a number!" if sel < 0
+	  raise "Item with index '#{sel + 1}' not found." unless list[sel]
+	  list[sel]
+	}
+	  
+	if ret.length > 1 and !multi_select
+	  raise "Only one item allowe"
+	end   
+      rescue
+	print "#{$!}\n"
+	ret = nil
+      end   
+    end
+    return indexes if options[:return_indexes]      
+    ret
+  end
+
+  CONSOLE_COLOR_STRINGS = {
+    :gray   => [1,30], :black       => [30],
+    :light_red    => [1,31], :red    => [31],
+    :light_green  => [1,32], :green  => [32],
+    :light_yellow => [1,33], :yellow => [33],
+    :light_blue   => [1,34], :blue   => [34],
+    :light_purple => [1,35], :purple => [35],
+    :light_cyan   => [1,36], :cyan   => [36],
+    :white  => [1,37], :light_gray  => [37],
+    :underscore => [4],
+    :blink => [5],
+    :inverse => [7],
+    :concealed => [8],
+    :default => [0]
+  }
+  CONSOLE_COLORS = CONSOLE_COLOR_STRINGS.keys
+   
+  def test_colors
+    CONSOLE_COLORS.sort_by{|n| n.to_s}.each {|color|
+      print "#{color}: " + colorize(color) { "****" } + "\n"
+    }
+  end
+
+  def console_commands(commands) ; commands.map {|number| "\e[#{number}m"}.join ;end
+
+  def colorize(color)
+    raise "Unexpected color: #{color}" unless CONSOLE_COLORS.include?(color)    
+    console_commands(CONSOLE_COLOR_STRINGS[color]) +
+      yield +
+      console_commands(CONSOLE_COLOR_STRINGS[:default])
+  end
+
+  def progress_bar_implementation(text,total)
+    ret = nil
+    begin
+      require "progressbar"
+      @pbar = ProgressBar.new(text, total)
+      #      $pbar.format = "%-#{title.length+10}s %3d%% %s %s"
+      ret = yield
+      pmsg
+      @pbar.finish
+      @pbar = nil
+    ensure
+      if @pbar
+	@pbar.halt
+	@pbar = nil
+      end
+    end
+    ret
+  end
+  def progress(count)
+    @pbar.set(count) if @pbar
+  end
+
+  def progress_message(message)
+    return unless @pbar
+    width = (@pbar.instance_eval("get_width")) - 6
+    if message.length > width then
+      message = message[0..(width/2)] + ">..<" + message[-(width/2)..-1]
+    end
+    
+    STDERR.print("\n")
+    STDERR.print("\e[K")
+    STDERR.print(message.to_s)
+    STDERR.print("\e[#{message.to_s.length}D")
+    STDERR.print("\e[1A")
+  end
+  def progress_inc
+    return unless @pbar
+    @pbar.inc
+  end
+
+  def execute_in_console(command, options = {})
+    system(command)
+  end
+
+  def shell
+    shell_name = "bash"
+    print("\nFallen into #{shell_name} shell\n")
+    print("(CTRL-D) for exit\n\n")
+    system("/bin/#{shell_name} < /dev/tty > /dev/tty 2> /dev/tty")
+  end
+
+  def diff(file1, file2, options = {})
+    text = result_of_system("diff -r -u '#{file1}' '#{file2}'",true)
+    color1 = :green
+    color2 = :red
+    # additional lines
+    text = text.gsub(/^\+.*$/) {|l| colorize(color1) { l }}
+    # removed lines
+    text = text.gsub(/^\-.*$/) {|l| colorize(color2) { l }}
+    print text
+    $?.success?    
+  end
+  
+# single character input  
+#       require 'termios'
+#     
+#     # Set up termios so that it returns immediately when you press a key.
+#     # (http://blog.rezra.com/articles/2005/12/05/single-character-input)
+#     t = Termios.tcgetattr(STDIN)
+#     t.lflag &= ~Termios::ICANON
+#     Termios.tcsetattr(STDIN,0,t)
+#     c = ''
+#     while c != 'q' do
+#       c = STDIN.getc.chr
+#       puts "You entered: " + c.inspect
+#     end
+
+
+end
+