inprovise 0.2.2

data/lib/inprovise/control.rb

@@ -0,0 +1,326 @@
+# Controller for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'monitor'
+
+class Inprovise::Controller
+
+  class << self
+
+    def controllers
+      @controllers ||= Array.new.extend(MonitorMixin)
+    end
+    private :controllers
+
+    def add(ctrl)
+      controllers.synchronize do
+        controllers << ctrl if ctrl
+      end
+      ctrl
+    end
+    private :add
+
+    def head
+      controllers.synchronize do
+        return controllers.first
+      end
+    end
+    private :head
+
+    def shift
+      controllers.synchronize do
+        return controllers.shift
+      end
+    end
+    private :shift
+
+    def empty?
+      controllers.synchronize do
+        return controllers.empty?
+      end
+    end
+    private :empty?
+
+    def get_value(v)
+      begin
+        Module.new { def self.eval(s); binding.eval(s); end }.eval(v)
+      rescue Exception
+        v
+      end
+    end
+    private :get_value
+
+    def list_scripts(options)
+      # load all specified schemes
+      (Array === options[:scheme] ? options[:scheme] : [options[:scheme]]).each {|s| Inprovise::DSL.include(s) }
+      $stdout.puts
+      $stdout.puts "   PROVISIONING SCRIPTS"
+      $stdout.puts "   ===================="
+      Inprovise::ScriptIndex.default.scripts.sort.each do |scrname|
+        script = Inprovise::ScriptIndex.default.get(scrname)
+        if script.description || options[:all]
+          script.describe.each {|l| $stdout.puts "   #{l}" }
+        end
+      end
+    end
+
+    def parse_config(cfg, opts = {})
+      cfg.inject(opts) do |rc,cfg|
+        k,v = cfg.split('=')
+        k = k.split('.')
+        h = rc
+        while k.size > 1
+          hk = k.shift.to_sym
+          raise ArgumentError, "Conflicting config category #{hk}" unless !h.has_key?(hk) || Hash === h[hk]
+          h = (h[hk] ||= {})
+        end
+        h.store(k.shift.to_sym, get_value(v))
+        rc
+      end
+    end
+
+    def run(command, options, *args)
+      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)
+          end
+        else # :apply, :revert, :validate or :trigger
+          # load all specified schemes
+          (Array === options[:scheme] ? options[:scheme] : [options[:scheme]]).each {|s| Inprovise::DSL.include(s) }
+          # extract config
+          cfg = parse_config(options[:config])
+          # get script/action
+          sca = args.shift
+          run_provisioning_command(command, sca, cfg, *args)
+        end
+      rescue Exception => e
+        cleanup!
+        raise e
+      end
+    end
+
+    def wait!
+      ex = nil
+      begin
+        while !empty?
+          head.wait
+          shift
+        end
+      rescue Exception => e
+        ex = e
+      ensure
+        cleanup!
+        raise ex if ex
+      end
+    end
+
+    def cleanup!
+      while !empty?
+        head.cleanup rescue Exception $stderr.puts $!.backtrace
+        shift
+      end
+    end
+
+    def run_node_command(cmd, options, *names)
+      add(Inprovise::Controller.new).run_node_command(cmd, options, *names)
+    end
+
+    def run_group_command(cmd, options, *names)
+      add(Inprovise::Controller.new).run_group_command(cmd, options, *names)
+    end
+
+    def run_provisioning_command(command, script, opts, *targets)
+      add(Inprovise::Controller.new).run_provisioning_command(command, script, opts, *targets)
+    end
+
+  end
+
+  def initialize
+    @targets = []
+    @threads = []
+  end
+
+  def wait
+    return if @threads.empty?
+    Inprovise.log.local('Waiting for controller threads...') if Inprovise.verbosity > 0
+    @threads.each { |t| t.join }
+  end
+
+  def cleanup
+    return if @targets.empty?
+    Inprovise.log.local('Disconnecting...') if Inprovise.verbosity > 0
+    @targets.each {|tgt| tgt.disconnect! }
+    Inprovise.log.local('Done!') if Inprovise.verbosity > 0
+  end
+
+  def run_provisioning_command(command, cmdtgt, opts, *names)
+    # get intended infrastructure targets/config tuples
+    targets = get_targets(*names)
+    # create runner/config for each target/config
+    runners = targets.map do |tgt, cfg|
+      @targets << tgt
+      [
+        if command == :trigger
+          Inprovise::TriggerRunner.new(tgt, cmdtgt)
+        else
+          Inprovise::ScriptRunner.new(tgt, Inprovise::ScriptIndex.default.get(cmdtgt), Inprovise.skip_dependencies)
+        end,
+        cfg
+      ]
+    end
+    # execute runners
+    if Inprovise.sequential
+      runners.each {|runner, cfg| exec(runner, command, cfg.merge(opts)) }
+    else
+      @threads = runners.map {|runner, cfg| Thread.new { exec(runner, command, cfg.merge(opts)) } }
+    end
+  end
+
+  def run_node_command(command, options, *names)
+    case command
+    when :add
+      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))
+
+      Inprovise.log.local("Adding #{node.to_s}")
+
+      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
+        node.add_to(grp)
+      end
+    when :remove
+      names.each do |name|
+        node = Inprovise::Infrastructure.find(name)
+        raise ArgumentError, "Invalid node #{name}" unless node && node.is_a?(Inprovise::Infrastructure::Node)
+
+        Inprovise.log.local("Removing #{node.to_s}")
+
+        Inprovise::Infrastructure.deregister(name)
+      end
+    when :update
+      @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) }
+      else
+        threads = @targets.map {|tgt| Thread.new { run_target_update(tgt, opts.dup, options) } }
+        threads.each {|t| t.join }
+      end
+    end
+    Inprovise::Infrastructure.save
+  end
+
+  def run_group_command(command, options, *names)
+    case command
+    when :add
+      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])
+
+      Inprovise.log.local("Adding #{grp.to_s}")
+
+      options[:target].each do |t|
+        tgt = Inprovise::Infrastructure.find(t)
+        raise ArgumentError, "Unknown target #{t}" unless tgt
+        tgt.add_to(grp)
+      end
+    when :remove
+      names.each do |name|
+        grp = Inprovise::Infrastructure.find(name)
+        raise ArgumentError, "Invalid group #{name}" unless grp && grp.is_a?(Inprovise::Infrastructure::Group)
+
+        Inprovise.log.local("Removing #{grp.to_s}")
+
+        Inprovise::Infrastructure.deregister(name)
+      end
+    when :update
+      groups = names.collect do |name|
+        grp = Inprovise::Infrastructure.find(name)
+        raise ArgumentError, "Invalid group #{name}" unless grp && grp.is_a?(Inprovise::Infrastructure::Group)
+        grp
+      end
+      opts = self.class.parse_config(options[:config])
+      grp_tgts = options[:target].collect do |t|
+                   tgt = Inprovise::Infrastructure.find(t)
+                   raise ArgumentError, "Unknown target #{t}" unless tgt
+                   tgt
+                 end
+      groups.each do |grp|
+        Inprovise.log.local("Updating #{grp.to_s}")
+
+        grp.config.clear if options[:reset]
+        grp.config.merge!(opts)
+        grp_tgts.each {|tgt| tgt.add_to(grp) }
+      end
+    end
+    Inprovise::Infrastructure.save
+  end
+
+  private
+
+  def get_targets(*names)
+    names.inject({}) do |hsh, name|
+      tgt = Inprovise::Infrastructure.find(name)
+      raise ArgumentError, "Unknown target [#{name}]" unless tgt
+      tgt.targets_with_config.each do |tgt_, cfg|
+        if hsh.has_key?(tgt_)
+          hsh[tgt_].merge!(cfg)
+        else
+          hsh[tgt_] = cfg
+        end
+      end
+      hsh
+    end
+  end
+
+  def exec(runner, command, opts)
+    if Inprovise.demonstrate
+      runner.demonstrate(command, opts)
+    else
+      runner.execute(command, opts)
+    end
+  end
+
+  def run_target_update(tgt, tgt_opts, options)
+    Inprovise.log.local("Updating #{tgt.to_s}")
+
+    if options[:reset]
+      # preserve :host
+      tgt_opts[:host] = tgt.get(:host) if tgt.get(:host)
+      # preserve :user if no new user specified
+      tgt_opts[:user] = tgt.get(:user) if tgt.get(:user) && !tgt_opts.has_key?(:user)
+      # preserve sniffed attributes when not running sniffers now
+      unless options[:sniff]
+        tgt_opts[:attributes] = tgt.get(:attributes)
+      end
+      # clear the target config
+      tgt.config.clear
+    end
+    tgt.config.merge!(tgt_opts) # 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]
+    options[:group].each do |g|
+      grp = Inprovise::Infrastructure.find(g)
+      raise ArgumentError, "Unknown group #{g}" unless grp
+      tgt.add_to(grp)
+    end
+  end
+
+end

data/lib/inprovise/execution_context.rb

@@ -0,0 +1,277 @@
+# Execution context for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'open3'
+require 'ostruct'
+
+class Inprovise::ExecutionContext
+
+  class DSL
+    def initialize(context)
+      @context = context
+    end
+
+    def method_missing(meth, *args)
+      @context.config.send(meth, *args)
+    end
+
+    def node
+      @context.node
+    end
+
+    def config
+      @context.config
+    end
+
+    def as(user, &blk)
+      @context.as(user, &blk)
+    end
+
+    def in_dir(path, &blk)
+      @context.in_dir(path, &blk)
+    end
+
+    def run_local(cmd)
+      @context.run_local(cmd)
+    end
+
+    def run(cmd, opts={})
+      @context.run(cmd, opts)
+    end
+
+    def sudo(cmd, opts={})
+      @context.sudo(cmd, opts)
+    end
+
+    def env(var)
+      @context.env(var)
+    end
+
+    def log(msg=nil)
+      @context.log(msg)
+    end
+
+    def upload(from, to)
+      @context.upload(from, to)
+    end
+
+    def download(from, to)
+      @context.download(from, to)
+    end
+
+    def mkdir(path)
+      @context.mkdir(path)
+    end
+
+    def remove(path)
+      @context.delete(path)
+    end
+
+    def local(path)
+      @context.local(path)
+    end
+
+    def remote(path)
+      @context.remote(path)
+    end
+
+    def template(path)
+      @context.template(path)
+    end
+
+    def trigger(action_ref, *args)
+      @context.trigger(action_ref, *args)
+    end
+
+    def binary_exists?(binary)
+      @context.binary_exists?(binary)
+    end
+  end
+
+  attr_reader :node, :config
+  attr_accessor :script
+
+  def initialize(node, log, index, config=nil)
+    @node = node
+    @log = log
+    @node.log_to(@log)
+    @config = init_config(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)
+    else
+      DSL.new(self).instance_exec(*args, &blk)
+    end
+  end
+
+  def as(user, &blk)
+    for_user(user).exec(blk)
+  end
+
+  def in_dir(path, &blk)
+    rc = nil
+    old_cwd = @node.helper.set_cwd(path)
+    begin
+      rc = exec(blk)
+    ensure
+      @node.helper.set_cwd(old_cwd)
+    end
+    rc
+  end
+
+  def for_user(user)
+    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)
+  end
+
+  def run_local(cmd)
+    @log.local(cmd)
+    stdout, stderr, status = Open3.capture3(cmd)
+    @log.stdout(stdout)
+    @log.stderr(stderr)
+  end
+
+  def run(cmd, opts={})
+    @node.run(cmd, opts)
+  end
+
+  def sudo(cmd, opts={})
+    @node.sudo(cmd, opts)
+  end
+
+  def env(var)
+    @node.env(var)
+  end
+
+  def log(msg=nil)
+    @log.log(msg) if msg
+    @log
+  end
+
+  def upload(from, to)
+    @node.upload(from, to)
+  end
+
+  def download(from, to)
+    @node.download(from, to)
+  end
+
+  def mkdir(path)
+    @node.mkdir(path)
+  end
+
+  def remove(path)
+    @node.delete(path)
+  end
+
+  def copy(from, to)
+    @node.copy(from, to)
+  end
+
+  def local(path)
+    Inprovise::LocalFile.new(path)
+  end
+
+  def remote(path)
+    Inprovise::RemoteFile.new(self, path)
+  end
+
+  def set_permissions(path, mask)
+    @node.set_permissions(path, mask)
+  end
+
+  def set_owner(path, user, group=nil)
+    @node.set_owner(path, user, group)
+  end
+
+  def template(path)
+    Inprovise::Template.new(path, self)
+  end
+
+  def trigger(action_ref, *args)
+    action_name, pkg_name = *action_ref.split(':', 2).reverse
+    pkg = @script
+    pkg = @index.get(pkg_name) if pkg_name
+    action = pkg.actions[action_name] if pkg
+    raise Inprovise::MissingActionError.new(action_ref) unless action
+    curtask = @node.log.set_task(action_ref)
+    curscript = @script
+    @script = pkg
+    @script.merge_configuration(self.config)
+    begin
+      exec(action, *args)
+    ensure
+      @script = curscript
+      @node.log.set_task(curtask)
+    end
+  end
+
+  def binary_exists?(binary)
+    @node.binary_exists?(binary)
+  end
+end
+
+class Inprovise::MissingActionError < StandardError
+  def initialize(action_ref)
+    @action_ref = action_ref
+  end
+
+  def message
+    "Action '#{@action_ref}' could not be found."
+  end
+end
+
+class Inprovise::MockExecutionContext < Inprovise::ExecutionContext
+  def run(cmd)
+    @log.mock_execute(cmd)
+    ''
+  end
+
+  def sudo(cmd)
+    @log.mock_execute "sudo #{cmd}"
+    ''
+  end
+
+  def upload(from, to)
+    @log.mock_execute("UPLOAD: #{from} => #{to}")
+  end
+
+  def download(from, to)
+    @log.mock_execute("DOWLOAD: #{to} <= #{from}")
+  end
+
+  def mkdir(path)
+    @log.mock_execute("MKDIR: #{path}")
+  end
+
+  def remove(path)
+    @log.mock_execute("REMOVE: #{path}")
+  end
+
+  def copy(from, to)
+    @log.mock_execute("COPY: #{from} #{to}")
+  end
+
+  def set_permissions(path, mask)
+    @log.mock_execute("SET_PERMISSIONS: #{path} #{'%o' % mask}")
+  end
+
+  def set_owner(path, user, group=nil)
+    @log.mock_execute("SET_OWNER: #{path} #{user} #{group ? " #{group}" : ''}")
+  end
+end

data/lib/inprovise/group.rb

@@ -0,0 +1,67 @@
+# Infrastructure group for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'json'
+
+class Inprovise::Infrastructure::Group < Inprovise::Infrastructure::Target
+
+  def initialize(name, config={}, targets=[])
+    @targets = targets.collect {|t| Inprovise::Infrastructure::Target === t ? t.name : t.to_s }
+    super(name, config)
+  end
+
+  def add_target(tgt)
+    tgt = Inprovise::Infrastructure::Target === tgt ? tgt : Inprovise::Infrastructure.find(tgt.to_s)
+    raise ArgumentError, "Circular reference detected in [#{tgt.to_s}] to [#{self.to_s}]" if tgt.includes?(self)
+    @targets << (Inprovise::Infrastructure::Target === tgt ? tgt.name : tgt.to_s)
+  end
+
+  def remove_target(tgt)
+    @targets.delete(Inprovise::Infrastructure::Target === tgt ? tgt.name : tgt.to_s)
+  end
+
+  def targets
+    @targets.collect {|t| Inprovise::Infrastructure.find(t).targets }.flatten.uniq
+  end
+
+  def targets_with_config
+    @targets.inject({}) do |hsh, t|
+      Inprovise::Infrastructure.find(t).targets_with_config.each do |tgt, cfg|
+        if hsh.has_key?(tgt)
+          hsh[tgt].merge!(cfg)
+        else
+          hsh[tgt] = cfg
+        end
+        hsh[tgt].merge!(config)
+      end
+      hsh
+    end
+  end
+
+  def includes?(tgt)
+    tgtname = Inprovise::Infrastructure::Target === tgt ? tgt.name : tgt.to_s
+    @targets.include?(tgtname) || @targets.any? {|t| Inprovise::Infrastructure.find(t).includes?(tgtname) }
+  end
+
+  def to_s
+    "Group:#{name}"
+  end
+
+  def to_json(*a)
+    {
+      JSON.create_id  => self.class.name,
+      :data => {
+        :name => name,
+        :config => config,
+        :targets => @targets
+      }
+    }.to_json(*a)
+  end
+
+  def self.json_create(o)
+    data = o[:data]
+    new(data[:name], data[:config], data[:targets])
+  end
+end

data/lib/inprovise/helper/cygwin.rb

@@ -0,0 +1,43 @@
+# Windows Cygwin Command helper for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+Inprovise::CmdHelper.define('cygwin', Inprovise::CmdHelper.implementations['linux']) do
+
+  def initialize(channel)
+    super(channel)
+    # only if this is *NOT* a sudo helper
+    unless channel.node.user == admin_user
+      if channel.node.config.has_key?(:credentials) && channel.node.config[:credentials].has_key?(:'public-key')
+        # trigger sudo channel creation to have pubkey installed for admin as well
+        sudo
+      end
+    end
+  end
+
+  # platform properties
+
+  def admin_user
+    'administrator'
+  end
+
+  def env_reference(varname)
+    "\$#{varname}"
+  end
+
+  # generic command execution
+
+  def sudo
+    return self if channel.node.user == admin_user
+    unless @sudo
+      @sudo = channel.node.for_user(admin_user, "sudo:#{channel.node.user}").helper
+    end
+    @sudo.set_cwd(self.cwd)
+    @sudo.channel.node.log_to(channel.node.log.clone_for_node(@sudo.channel.node))
+    @sudo
+  end
+
+  # basic commands
+
+end