inprovise 0.2.7 → 0.2.8

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YWVkNzEwYzZlNTI3ZGM0ZjE5NTY2ZjY5MzY5NWNhZTRiMDM2MjFiNw==
+    ZWIzZmMxNTQzOTY1MjAxNTZiYjE2ZjQwNzZjZDg1ZDQwMDA3MWMxMg==
   data.tar.gz: !binary |-
-    ODJlMDRmMTBjMmYxNTEwMTMzZTRlMDY5ZjdlZDI0MGQ1NzZjOGQ3OQ==
+    YzYzYjJlYzc2MmYxOTFkYTJjY2Q0ZmY3Njg5MWFlYzc0NDU0MGUzNw==
 SHA512:
   metadata.gz: !binary |-
-    NzEwM2RiMjdkMDMyYTBjYTgzYjFiOWZlYzU2ZjBiODM3ZjA1ZGNiMzY4MzA4
-    MTAwODUyNTY3ZDZiYzQwYjAzMGU1YzdjN2RlYzljZmI0YmVhM2Q1OGFjOGRi
-    YWIzMjYxYWM0YmM4ODQ3MjIwNzBlN2I5NDkzMzNlOTMyMzJhZWU=
+    MDljNzdlYTgwNTEyM2I4YmNkMzE0Y2NlYTJhMWRhMjJiYzUyNGRiMjQ4YmEx
+    NmViZmRmMTUzNGJiMWRkNDg4YmEzYjNjMDAyMzI1OWVhMmNiMGU1MjBiYmJl
+    ZjU1YTZkYzUzZTk0ZjdlNDMzNzExMGM1MTYwNWI4MjZiZTI1ZTA=
   data.tar.gz: !binary |-
-    MDkzNjdhYzc0ZGNiMWVkOTIzMzAzNzhjOTVkM2UwNzNjNzRmMmEyOThhZDEz
-    Y2JiZTQ0ZWFjMTFhMmIyMmUwNmM5MTA3OTBmYzJhOGFlYWUyY2ZhMWIxZjEx
-    NzBmYWQzMjRhZjhmOGIyNjNmNzk1ODQzNDcxNzhlZGMzOGVmM2M=
+    YTc2YjdjYzc3MGFkMGM3NDgwNGRjOWI2OGE0MTA4NjVkMDNjOTA0NDgyMDZi
+    ZWQ0NWMyMjcyMWYyNzliM2JlMzk0ZmFlZDhkMjMzNDQzMWFiMzk0MjI5YzVj
+    YmI4MGRiYWJmMDY2ZGJkNmE3ZTA1OGZjMWRiNjc2MWNhYWI2MWU=

data/lib/inprovise/channel/ssh.rb

@@ -191,11 +191,15 @@ Inprovise::CmdChannel.define('ssh') do
   def execute(cmd, forcelog=false)
     @node.log.remote("SSH: #{cmd}") if Inprovise.verbosity > 1 || forcelog
     output = ''
-    connection.exec! cmd do |_channel, stream, data|
-      output << data if stream == :stdout
-      data.split("\n").each do |line|
-        @node.log.send(stream, line, forcelog)
-      end if Inprovise.verbosity > 1 || forcelog
+    begin
+      connection.exec! cmd do |_channel, stream, data|
+        output << data if stream == :stdout
+        @node.log.send(stream, data, forcelog) if Inprovise.verbosity > 1 || forcelog
+      end
+    rescue Net::SSH::Exception => ex
+      raise Inprovise::CmdChannel::Exception, "#{ex.message}"
+    ensure
+      @node.log.flush_all if Inprovise.verbosity > 1 || forcelog
     end
     output
   end

data/lib/inprovise/cmd_channel.rb

@@ -5,6 +5,8 @@
 
 module Inprovise::CmdChannel
 
+  class Exception < ::RuntimeError; end
+
   class << self
 
     def implementations

data/lib/inprovise/config.rb

@@ -0,0 +1,94 @@
+# Config class for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+class Inprovise::Config
+
+  def initialize(other=nil)
+    @table = {}
+    copy!(other.to_h) if other
+  end
+
+  def _k_(key)
+    Symbol === key ? key : key.to_s.to_sym
+  end
+  private :_k_
+
+  def _v_(val)
+    Hash === val ? self.class.new.merge!(val) : val
+  end
+  private :_v_
+
+  def [](key)
+    @table[_k_(key)]
+  end
+
+  def []=(key, val)
+    @table[_k_(key)] = _v_(val)
+  end
+
+  def has_key?(key)
+    @table.has_key?(_k_(key))
+  end
+
+  def empty?
+    @table.empty?
+  end
+
+  def merge!(other)
+    other.to_h.each do |k,v|
+      case self[k]
+      when self.class
+        self[k].merge!(v)
+      else
+        self[k] = v
+      end
+    end
+    self
+  end
+
+  def copy!(other)
+    other.to_h.each do |k,v|
+      case self[k]
+      when self.class
+        self[k].copy!(v)
+      else
+        self[k] = v.is_a?(Hash) ? v : (v.dup rescue v)
+      end
+    end
+    self
+  end
+
+  def update!(other)
+    other.to_h.each do |k,v|
+      if self.has_key?(k)
+        self[k].update!(v) if self.class === self[k]
+      else
+        self[k] = v.is_a?(Hash) ? v : (v.dup rescue v)
+      end
+    end
+    self
+  end
+
+  def each(&block)
+    @table.each { |k,v| block.call(k,v) }
+  end
+
+  def dup
+    self.class.new(@table)
+  end
+
+  def to_h
+    @table
+  end
+
+  def method_missing(method, *args)
+    if /(.*)=$/ =~ method.to_s
+      self[$1] = (args.size > 1 ? args : args.shift)
+    else
+      self[method]
+    end
+  end
+
+end

data/lib/inprovise/control.rb

@@ -87,11 +87,13 @@ class Inprovise::Controller
       begin
         case command
         when :add, :remove, :update
-          case args.shift
-          when :node
-            run_node_command(command, options, *args)
-          when :group
-            run_group_command(command, options, *args)
+          target = args.shift
+          if command == :remove
+            run_infra_command(command, target, *args)
+          else
+            tgtcfg = parse_config(options[:config])
+            tgtcfg[:credentials] = parse_config(options[:credential]) if target == :node && options.has_key?(:credential)
+            run_infra_command(command, target, options, tgtcfg, *args)
           end
         else # :apply, :revert, :validate or :trigger
           load_schemes(options)
@@ -129,18 +131,13 @@ class Inprovise::Controller
       end
     end
 
-    def run_node_command(cmd, options, *names)
-      add(Inprovise::Controller.new).send(:"#{cmd}_node", options, *names)
+    def run_infra_command(cmd, target, *args)
+      add(Inprovise::Controller.new).send(:"#{cmd}_#{target}", *args)
       Inprovise::Infrastructure.save
     end
 
-    def run_group_command(cmd, options, *names)
-      add(Inprovise::Controller.new).send(:"#{cmd}_group", options, *names)
-      Inprovise::Infrastructure.save
-    end
-
-    def run_provisioning_command(command, script, opts, *targets)
-      add(Inprovise::Controller.new).run_provisioning_command(command, script, opts, *targets)
+    def run_provisioning_command(command, script, cfg, *targets)
+      add(Inprovise::Controller.new).run_provisioning_command(command, script, cfg, *targets)
     end
 
   end
@@ -163,11 +160,11 @@ class Inprovise::Controller
     Inprovise.log.local('Done!') if Inprovise.verbosity > 0
   end
 
-  def run_provisioning_command(command, cmdtgt, opts, *names)
+  def run_provisioning_command(command, cmdtgt, cmdcfg, *names)
     # get intended infrastructure targets/config tuples
     targets = get_targets(*names)
     # create runner/config for each target/config
-    runners = targets.map do |tgt, cfg|
+    runners = targets.map do |tgt, tgtcfg|
       @targets << tgt
       [
         if command == :trigger
@@ -175,21 +172,20 @@ class Inprovise::Controller
         else
           Inprovise::ScriptRunner.new(tgt, Inprovise::ScriptIndex.default.get(cmdtgt), Inprovise.skip_dependencies)
         end,
-        cfg
+        tgtcfg
       ]
     end
     # execute runners
     if Inprovise.sequential
-      runners.each {|runner, cfg| exec(runner, command, cfg.merge(opts)) }
+      runners.each {|runner, tgtcfg| exec(runner, command, tgtcfg.merge(cmdcfg)) }
     else
-      @threads = runners.map {|runner, cfg| Thread.new { exec(runner, command, cfg.merge(opts)) } }
+      @threads = runners.map {|runner, tgtcfg| Thread.new { exec(runner, command, tgtcfg.merge(cmdcfg)) } }
     end
   end
 
-  def add_node(options, *names)
-    opts = self.class.parse_config(options[:config], { host: options[:address] })
-    opts[:credentials] = self.class.parse_config(options[:credential])
-    @targets << (node = Inprovise::Infrastructure::Node.new(names.first, opts))
+  def add_node(options, nodecfg, name)
+    nodecfg.merge!({ host: options[:address] })
+    @targets << (node = Inprovise::Infrastructure::Node.new(name, nodecfg))
 
     Inprovise.log.local("Adding #{node}")
 
@@ -202,7 +198,7 @@ class Inprovise::Controller
     end
   end
 
-  def remove_node(_options, *names)
+  def remove_node(*names)
     names.each do |name|
       node = Inprovise::Infrastructure.find(name)
       raise ArgumentError, "Invalid node #{name}" unless node && node.is_a?(Inprovise::Infrastructure::Node)
@@ -213,26 +209,23 @@ class Inprovise::Controller
     end
   end
 
-  def update_node(options, *names)
+  def update_node(options, nodecfg, *names)
     @targets = names.collect do |name|
       tgt = Inprovise::Infrastructure.find(name)
       raise ArgumentError, "Unknown target [#{name}]" unless tgt
       tgt.targets
     end.flatten.uniq
-    opts = self.class.parse_config(options[:config])
-    opts[:credentials] = self.class.parse_config(options[:credential])
     if Inprovise.sequential || (!options[:sniff]) || @targets.size == 1
-      @targets.each {|tgt| run_target_update(tgt, opts.dup, options) }
+      @targets.each {|tgt| run_node_update(tgt, nodecfg.dup, options) }
     else
-      threads = @targets.map {|tgt| Thread.new { run_target_update(tgt, opts.dup, options) } }
+      threads = @targets.map {|tgt| Thread.new { run_node_update(tgt, nodecfg.dup, options) } }
       threads.each {|t| t.join }
     end
   end
 
-  def add_group(options, *names)
+  def add_group(options, grpcfg, name)
     options[:target].each {|t| raise ArgumentError, "Unknown target [#{t}]" unless Inprovise::Infrastructure.find(t) }
-    opts = self.class.parse_config(options[:config])
-    grp = Inprovise::Infrastructure::Group.new(names.first, opts, options[:target])
+    grp = Inprovise::Infrastructure::Group.new(name, grpcfg, options[:target])
 
     Inprovise.log.local("Adding #{grp}")
 
@@ -243,7 +236,7 @@ class Inprovise::Controller
     end
   end
 
-  def remove_group(_options, *names)
+  def remove_group(*names)
     names.each do |name|
       grp = Inprovise::Infrastructure.find(name)
       raise ArgumentError, "Invalid group #{name}" unless grp && grp.is_a?(Inprovise::Infrastructure::Group)
@@ -254,13 +247,12 @@ class Inprovise::Controller
     end
   end
 
-  def update_group(options, *names)
+  def update_group(options, grpcfg, *names)
     groups = names.collect do |name|
       tgt = Inprovise::Infrastructure.find(name)
       raise ArgumentError, "Invalid group #{name}" unless tgt && tgt.is_a?(Inprovise::Infrastructure::Group)
       tgt
     end
-    opts = self.class.parse_config(options[:config])
     grp_tgts = options[:target].collect do |tnm|
       tgt = Inprovise::Infrastructure.find(tnm)
       raise ArgumentError, "Unknown target #{tnm}" unless tgt
@@ -270,7 +262,7 @@ class Inprovise::Controller
       Inprovise.log.local("Updating #{grp}")
 
       grp.config.clear if options[:reset]
-      grp.config.merge!(opts)
+      grp.config.merge!(grpcfg)
       grp_tgts.each {|gt| gt.add_to(grp) }
     end
   end
@@ -292,37 +284,37 @@ class Inprovise::Controller
     end
   end
 
-  def exec(runner, command, opts)
+  def exec(runner, command, cfg)
     if Inprovise.demonstrate
-      runner.demonstrate(command, opts)
+      runner.demonstrate(command, cfg)
     else
-      runner.execute(command, opts)
+      runner.execute(command, cfg)
     end
   end
 
-  def run_target_update(tgt, tgt_opts, options)
-    Inprovise.log.local("Updating #{tgt}")
+  def run_node_update(node, nodecfg, options)
+    Inprovise.log.local("Updating #{node}")
 
     if options[:reset]
       # preserve :host
-      tgt_opts[:host] = tgt.get(:host) if tgt.get(:host)
+      nodecfg[:host] = node.get(:host) if node.get(:host)
       # preserve :user if no new user specified
-      tgt_opts[:user] = tgt.get(:user) if tgt.get(:user) && !tgt_opts.has_key?(:user)
+      nodecfg[:user] = node.get(:user) if node.get(:user) && !nodecfg.has_key?(:user)
       # preserve sniffed attributes when not running sniffers now
       unless options[:sniff]
-        tgt_opts[:attributes] = tgt.get(:attributes)
+        nodecfg[:attributes] = node.get(:attributes)
       end
-      # clear the target config
-      tgt.config.clear
+      # clear the node config
+      node.config.clear
     end
-    tgt.config.merge!(tgt_opts) # merge new + preserved config
+    node.config.merge!(nodecfg) # merge new + preserved config
     # force update of user if specified
-    tgt.prepare_connection_for_user!(tgt_opts[:user]) if tgt_opts[:user]
-    Inprovise::Sniffer.run_sniffers_for(tgt) if options[:sniff]
+    node.prepare_connection_for_user!(nodecfg[:user]) if nodecfg[:user]
+    Inprovise::Sniffer.run_sniffers_for(node) if options[:sniff]
     options[:group].each do |g|
       grp = Inprovise::Infrastructure.find(g)
       raise ArgumentError, "Unknown group #{g}" unless grp
-      tgt.add_to(grp)
+      node.add_to(grp)
     end
   end
 

data/lib/inprovise/execution_context.rb

@@ -4,7 +4,6 @@
 # License::   Distributes under the same license as Ruby
 
 require 'open3'
-require 'ostruct'
 
 class Inprovise::ExecutionContext
 
@@ -49,7 +48,7 @@ class Inprovise::ExecutionContext
       @context.env(var)
     end
 
-    def log(msg=nil)
+    def log(msg=nil, color=nil)
       @context.log(msg)
     end
 
@@ -97,18 +96,11 @@ class Inprovise::ExecutionContext
     @node = node
     @log = log
     @node.log_to(@log)
-    @config = init_config(config || @node.config)
+    @config = Inprovise::Config.new(config || @node.config)
     @index = index
     @script = nil
   end
 
-  def init_config(hash)
-    hash.to_h.reduce(OpenStruct.new(hash)) do |os,(k,v)|
-      os[k] = init_config(v) if Hash === v
-      os
-    end
-  end
-
   def exec(blk, *args)
     if args.empty?
       DSL.new(self).instance_eval(&blk)
@@ -136,7 +128,13 @@ class Inprovise::ExecutionContext
     return self if user.nil? || user == node.user
     new_node = @node.for_user(user)
     new_log = @log.clone_for_node(new_node)
-    self.class.new(new_node, new_log, @index, @config)
+    self.dup.setup_for_node!(new_node, new_log)
+  end
+
+  def setup_for_node!(node, log)
+    @node = node
+    @log = log
+    self
   end
 
   def run_local(cmd)
@@ -158,8 +156,8 @@ class Inprovise::ExecutionContext
     @node.env(var)
   end
 
-  def log(msg=nil)
-    @log.log(msg) if msg
+  def log(msg=nil, color=nil)
+    @log.log(msg, color) if msg
     @log
   end
 
@@ -216,7 +214,7 @@ class Inprovise::ExecutionContext
     curtask = @node.log.set_task(action_ref)
     curscript = @script
     @script = pkg
-    @script.merge_configuration(self.config)
+    @script.update_configuration(self)
     begin
       exec(action, *args)
     ensure

data/lib/inprovise/infra.rb

@@ -12,13 +12,13 @@ module Inprovise::Infrastructure
   JSON.create_id = 'json_class'
 
   def self.symbolize_keys(hsh)
-    return hsh unless Hash === hsh
+    return hsh unless ::Hash === hsh
     hsh.reduce({}) {|h, (k,v)| h[k.to_sym] = symbolize_keys(v); h }
   end
 
   class << self
     def targets
-      @targets ||= Hash.new.extend(MonitorMixin)
+      @targets ||= ::Hash.new.extend(::MonitorMixin)
     end
     private :targets
 

data/lib/inprovise/logger.rb

@@ -3,13 +3,27 @@
 # Author::    Martin Corino
 # License::   Distributes under the same license as Ruby
 
+require 'monitor'
+
 class Inprovise::Logger
   attr_accessor :node
   attr_reader :task
 
+  class << self
+    def streams
+      @streams ||= ::Hash.new.extend(::MonitorMixin).merge!({
+        :stdout => { :ios => $stdout, :buffer => [{col: nil, ln: '', cr: false}] },
+        :stderr => { :ios => $stderr, :buffer => [{col: nil, ln: '', cr: false}] }
+      })
+    end
+  end
+
   def initialize(node, task)
+    @streams = {
+      :stdout => { :ios => $stdout, :buffer => [{col: nil, ln: '', cr: false}] },
+      :stderr => { :ios => $stderr, :buffer => [{col: nil, ln: '', cr: false}] }
+    }
     @node = node
-    @nl = true
     set_task(task)
   end
 
@@ -49,35 +63,145 @@ class Inprovise::Logger
     say(cmd, :blue)
   end
 
-  def log(msg)
-    say(msg)
+  def log(msg, color=nil)
+    say(msg, color)
+  end
+
+  def synchronize(&block)
+    self.class.streams.synchronize do
+      block.call
+    end if block_given?
+  end
+  private :synchronize
+
+  def ios(stream=:stdout)
+    self.class.streams[stream][:ios]
+  end
+  private :ios
+
+  def buffer(stream=:stdout)
+    self.class.streams[stream][:buffer]
+  end
+  private :buffer
+
+  def put(msg, color=nil, stream=:stdout)
+    streambuf = buffer(stream)
+    streambuf.last[:col] ||= color
+    streambuf.last[:ln] << msg
+    streambuf
+  end
+  private :put
+
+  def puts(msg, color=nil, stream=:stdout)
+    put(msg, color, stream) << {col:nil, ln:'',cr:false}
+  end
+  private :puts
+
+  def do_print(stream=:stdout)
+    streambuf = buffer(stream)
+    while lnbuf = streambuf.shift
+      clear_to_eol = lnbuf[:cr]
+      lnbuf[:ln].scan(/([^\r]*)(\r)?/) do |txt, cr|
+        # do we have a (full) line to print?
+        if cr || !streambuf.empty?
+          out = lnbuf[:col] ? txt.to_s.send(lnbuf[:col]) : txt
+          unless txt.empty?
+            ios(stream).print "\r".to_eol if clear_to_eol
+            ios(stream).print "#{@node.to_s} [#{@task.bold}] #{out}"
+          end
+          ios(stream).flush if cr
+          ios(stream).puts unless cr || (txt.empty? && !clear_to_eol)
+          clear_to_eol = cr ? true : false
+          break unless cr # next line or cr?
+        else
+          streambuf << if txt.empty?
+            # restart with empty line
+            {col:nil,ln:'',cr:clear_to_eol}
+          else
+            # stuff the remaining text back for a next round
+            {col:lnbuf[:col],ln:txt,cr:clear_to_eol}
+          end
+          return
+        end
+      end
+    end
+  end
+  private :do_print
+
+  def do_flush(stream)
+    lnbuf = buffer(stream).last
+    unless lnbuf[:ln].empty? && !lnbuf[:cr]
+      # add an empty line buffer to force output of current buffered contents
+      buffer(stream) << {col:nil, ln:'',cr:false}
+      do_print(stream)
+    end
+  end
+  private :do_flush
+
+  def flush(stream=:stdout)
+    synchronize do
+      do_flush(stream)
+    end
+    self
   end
 
-  def print(msg)
-    Thread.exclusive do
-      $stdout.print "#{@node.to_s} [#{@task.bold}] " if @nl
-      $stdout.print msg.sub("\r", "\r".to_eol << "#{@node.to_s} [#{@task.bold}] ")
-      @nl = false
+  def flush_all
+    synchronize do
+      [:stderr, :stdout].each { |stream| do_flush(stream) }
     end
+    self
   end
 
-  def println(msg)
-    print(msg)
-    Thread.exclusive { $stdout.puts; @nl = true }
+  def print(msg, color=nil, stream=:stdout)
+    synchronize do
+      put(msg, color, stream)
+      do_print(stream)
+    end
+    self
+  end
+
+  def println(msg, color=nil, stream=:stdout)
+    synchronize do
+      puts(msg, color, stream)
+      do_print(stream)
+    end
+    self
+  end
+
+  def redirect(msg, color, stream)
+    synchronize do
+      msg.to_s.scan(/([^\n]*)(\n\r|\n)?/) do |txt,sep|
+        if sep
+          puts(txt, color, stream)
+        else
+          put(txt, color, stream)
+        end
+        break unless sep
+      end
+      do_print(stream)
+    end
+    self
   end
+  private :redirect
 
   def stdout(msg, force=false)
-    say(msg, :green) if force || Inprovise.verbosity>0
+    redirect(msg, :green, :stdout) if force || Inprovise.verbosity>0
   end
 
   def stderr(msg, force=false)
-    say(msg, :red, $stderr) if force || Inprovise.verbosity>0
+    redirect(msg, :red, :stderr) if force || Inprovise.verbosity>0
   end
 
-  def say(msg, color=nil, stream=$stdout)
-    msg.to_s.split("\n").each do |line|
-      out = color ? line.send(color) : line
-      Thread.exclusive { stream.puts unless @nl; stream.puts "#{@node.to_s} [#{@task.bold}] #{out}"; @nl = true }
+  def say(msg, color=nil, stream=:stdout)
+    synchronize do
+      [:stderr, :stdout].each { |stream| do_flush(stream) }
+      streambuf = buffer(stream)
+      msg.to_s.scan(/([^\n]*)(\n\r|\n)?/) do |txt,sep|
+        puts(txt)
+        break unless sep
+      end
+      do_print(stream)
     end
+    self
   end
 end

data/lib/inprovise/node.rb

@@ -252,8 +252,8 @@ class Inprovise::Infrastructure::Node < Inprovise::Infrastructure::Target
       output = exec.run(cmd, opts[:log])
       @history << {cmd:cmd, output:output}
       output
-    rescue Exception
-      raise RuntimeError, "Failed to communicate with [#{self}]"
+    rescue Inprovise::CmdChannel::Exception => ex
+      raise RuntimeError, "Failed to communicate with [#{self}] : #{ex.message}"
     end
   end
 

data/lib/inprovise/script.rb

@@ -3,10 +3,8 @@
 # Author::    Martin Corino
 # License::   Distributes under the same license as Ruby
 
-require 'ostruct'
-
 class Inprovise::Script
-  attr_reader :name, :dependencies, :actions, :children, :user
+  attr_reader :name, :dependencies, :actions, :children, :user, :configuration
 
   class DSL
     def initialize(script)
@@ -16,10 +14,12 @@ class Inprovise::Script
     def description(desc)
       @script.description(desc)
     end
+    alias :describe :description
 
-    def configuration(cfg)
-      @script.configuration(cfg)
+    def configure(cfg=nil, &block)
+      @script.configure(cfg, &block)
     end
+    alias :configuration :configure
 
     def depends_on(*scr_names)
       @script.depends_on(*scr_names)
@@ -73,48 +73,18 @@ class Inprovise::Script
     self.description.split("\n").collect {|ld| "#{"%-25s" % nm.shift.to_s}\t#{ld.strip}"}
   end
 
-  def configuration(cfg=nil)
-    @configuration = cfg if cfg
+  def configure(cfg=nil, &definition)
+    @configuration = Inprovise::Config.new.merge!(cfg) if cfg
+    command(:configure, &definition)
     @configuration
   end
 
-  def copy_config(cfg)
-    case cfg
-    when Hash, OpenStruct
-      cfg.to_h.reduce(OpenStruct.new) { |os, (k,v)| os[k] = copy_config(v); os }
-    when Array
-      cfg.collect { |e| copy_config(e) }
-    else
-      cfg.dup rescue cfg
+  def update_configuration(context)
+    if @configuration
+      context.config[self.name.to_sym] ||= Inprovise::Config.new
+      context.config[self.name.to_sym].update!(@configuration)
     end
   end
-  private :copy_config
-
-  def merge_config(runcfg, scrcfg)
-    return scrcfg unless runcfg
-    case runcfg
-    when Hash, OpenStruct
-      return runcfg unless scrcfg.respond_to?(:to_h)
-      return scrcfg.to_h.reduce(runcfg) do |rc, (k,v)|
-        case rc[k]
-        when Hash,OpenStruct
-          rc[k] = merge_config(rc[k], v)
-        else
-          rc[k] = v unless rc[k]
-        end
-        rc
-      end
-    else
-      return runcfg
-    end
-  end
-  private :merge_config
-
-  def merge_configuration(config)
-    return unless self.configuration
-    script_cfg = copy_config(self.configuration)
-    config[self.name.to_sym] = merge_config(config[self.name.to_sym], script_cfg)
-  end
 
   def depends_on(*scr_names)
     scr_names.each do |scr_name|

data/lib/inprovise/script_runner.rb

@@ -33,11 +33,13 @@ class Inprovise::ScriptRunner
   def execute(command_name, config=nil)
     Inprovise.log.local("#{COMMANDS[command_name].first} #{script.name} #{COMMANDS[command_name].last} #{@node.to_s}")
     scrs = scripts
-    scrs.reverse! if command_name.to_sym == :revert
-    @log.say scrs.map(&:name).join(', ').yellow if Inprovise.verbosity > 0
     context = @perform ? Inprovise::ExecutionContext.new(@node, @log, @index, config) : Inprovise::MockExecutionContext.new(@node, @log, @index, config)
-    context.config.command = command_name
-    scrs.each { |script| script.merge_configuration(context.config) }
+    context.config.command = command_name.to_sym
+    scrs.each do |script|
+      execute_configuration(script, context)
+    end
+    scrs.reverse! if command_name.to_sym == :revert
+    @log.say(scrs.map(&:name).join(', '), :yellow) if Inprovise.verbosity > 0
     scrs.each do |script|
       send(:"execute_#{command_name}", script, context)
     end
@@ -49,6 +51,11 @@ class Inprovise::ScriptRunner
     @perform = true
   end
 
+  def execute_configuration(script, context)
+    script.update_configuration(context)
+    exec(script, :configure, context)
+  end
+
   def execute_apply(script, context)
     return unless should_run?(script, :apply, context)
     exec(script, :apply, context)

data/lib/inprovise/version.rb

@@ -5,6 +5,6 @@
 
 module Inprovise
 
-  VERSION = '0.2.7'
+  VERSION = '0.2.8'
 
 end

data/lib/inprovise.rb

@@ -127,6 +127,7 @@ module Inprovise
 end
 
 require_relative './inprovise/version'
+require_relative './inprovise/config'
 require_relative './inprovise/logger'
 require_relative './inprovise/cmd_channel'
 require_relative './inprovise/cmd_helper'

data/test/config_test.rb

@@ -0,0 +1,124 @@
+# Config tests for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require_relative 'test_helper'
+
+describe Inprovise::Config do
+
+  it 'creates an empty instance' do
+    @config = Inprovise::Config.new
+    @config.empty?.must_equal true
+  end
+
+  it 'creates an instance from Hash' do
+    @config = Inprovise::Config.new({ :key => 'value'})
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    @config[:key].must_equal 'value'
+  end
+
+  it 'creates an instance from Config' do
+    tmp = Inprovise::Config.new({ :key => 'value'})
+    @config = Inprovise::Config.new(tmp)
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    @config[:key].must_equal 'value'
+  end
+
+  it 'copies initialization values' do
+    tmp = Inprovise::Config.new({ :key => %w{value1 value2}, :key2 => { :another => 999} })
+    @config = Inprovise::Config.new(tmp)
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    tmp[:key] << 'value3'
+    tmp[:key].size.must_equal 3
+    @config[:key].size.must_equal 2
+    tmp[:key].first << 'X'
+    # but not recursively (except for hashes/config)
+    tmp[:key].first.must_equal 'value1X'
+    @config[:key].first.must_equal 'value1X'
+    tmp[:key2][:another] = 100
+    tmp[:key2][:another].must_equal 100
+    @config[:key2][:another].must_equal 999
+  end
+
+  it 'merges configurations' do
+    tmp = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config = Inprovise::Config.new({ :key => 'value'})
+    @config.merge!(tmp)
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    @config[:key].must_equal 'value1'
+    @config[:key2].must_equal 'value2'
+  end
+
+  it 'copies configurations' do
+    tmp = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config = Inprovise::Config.new({ :key => 'value'})
+    @config.copy!(tmp)
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    tmp[:key].tr!('1', '')
+    tmp[:key].must_equal 'value'
+    @config[:key].must_equal 'value1'
+    @config[:key2].must_equal 'value2'
+  end
+
+  it 'updates configurations' do
+    tmp = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config = Inprovise::Config.new({ :key => 'value'})
+    @config.update!(tmp)
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    tmp[:key].must_equal 'value1'
+    @config[:key].must_equal 'value'
+    @config[:key2].must_equal 'value2'
+  end
+
+  it 'iterates content' do
+    @config = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config.each do |k,v|
+      [:key, :key2].must_include k
+      v.must_equal 'value1' if k == :key
+      v.must_equal 'value2' if k == :key2
+    end
+  end
+
+  it 'returns Hash' do
+    @config = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config.to_h.must_be_kind_of Hash
+    @config.to_h[:key].must_equal 'value1'
+  end
+
+  it 'duplicates Config' do
+    tmp = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config = tmp.dup
+    @config.empty?.must_equal false
+    @config.has_key?(:key).must_equal true
+    tmp[:key].tr!('1', '')
+    tmp[:key].must_equal 'value'
+    @config[:key].must_equal 'value1'
+    @config[:key2].must_equal 'value2'
+  end
+
+  it 'supports method_missing access to members' do
+    @config = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config.key.must_equal 'value1'
+    @config[:key2].must_equal 'value2'
+    @config.key2 = 'value3'
+    @config.key2.must_equal 'value3'
+    @config[:key2].must_equal 'value3'
+  end
+
+  it 'converts hashes to Config' do
+    @config = Inprovise::Config.new({ :key => 'value1', :key2 => 'value2'})
+    @config[:key3] = {}
+    @config[:key3].must_be_kind_of Inprovise::Config
+    @config.key4 = {}
+    @config.key4.must_be_kind_of Inprovise::Config
+    @config.key5 ||= {}
+    @config.key5.must_be_kind_of Inprovise::Config
+  end
+end

data/test/script_runner_test.rb

@@ -100,8 +100,8 @@ describe Inprovise::ScriptRunner do
 
       it 'validates before and after applying a script' do
         @runner = Inprovise::ScriptRunner.new(@node, 'validate')
-        @runner.expects(:exec).once
-               .with() { |script, cmd, context| script.name.must_equal('validate') && Inprovise::ExecutionContext === context && cmd == :apply }
+        @runner.expects(:exec).twice
+               .with() { |script, cmd, context| script.name.must_equal('validate') && Inprovise::ExecutionContext === context && (cmd == :configure || cmd == :apply) }
         @runner.expects(:is_valid?).twice
                .with() { |script, context| script.name.must_equal('validate') && Inprovise::ExecutionContext === context }
                .returns(false, true)
@@ -135,8 +135,8 @@ describe Inprovise::ScriptRunner do
 
       it 'validates before reverting a script' do
         @runner = Inprovise::ScriptRunner.new(@node, 'validate')
-        @runner.expects(:exec).once
-               .with() { |script, cmd, context| script.name.must_equal('validate') && Inprovise::ExecutionContext === context && cmd == :revert }
+        @runner.expects(:exec).twice
+               .with() { |script, cmd, context| script.name.must_equal('validate') && Inprovise::ExecutionContext === context && (cmd == :configure || cmd == :revert) }
         @runner.expects(:is_valid?).once
                .with() { |script, context| script.name.must_equal('validate') && Inprovise::ExecutionContext === context }
                .returns(true)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inprovise
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Martin Corino
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-08 00:00:00.000000000 Z
+date: 2016-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colored
@@ -108,6 +108,7 @@ files:
 - lib/inprovise/cli/provision.rb
 - lib/inprovise/cmd_channel.rb
 - lib/inprovise/cmd_helper.rb
+- lib/inprovise/config.rb
 - lib/inprovise/control.rb
 - lib/inprovise/execution_context.rb
 - lib/inprovise/group.rb
@@ -134,6 +135,7 @@ files:
 - lib/inprovise/version.rb
 - test/cli_test.rb
 - test/cli_test_helper.rb
+- test/config_test.rb
 - test/dsl_test.rb
 - test/fixtures/example.txt
 - test/fixtures/include.rb
@@ -175,6 +177,7 @@ summary: Simple, easy and intuitive infrastructure provisioning
 test_files:
 - test/cli_test.rb
 - test/cli_test_helper.rb
+- test/config_test.rb
 - test/dsl_test.rb
 - test/fixtures/example.txt
 - test/fixtures/include.rb