inprovise 0.2.2

data/lib/inprovise/node.rb

@@ -0,0 +1,271 @@
+# Infrastructure node for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'json'
+
+class Inprovise::Infrastructure::Node < Inprovise::Infrastructure::Target
+  attr_reader :host, :user
+
+  def initialize(name, config={})
+    @host = config[:host] || name
+    @user = config[:user] || 'root'
+    @channel = nil
+    @helper = nil
+    @history = []
+    @user_nodes = {}
+    super(name, config)
+  end
+
+  def channel
+    @channel ||= Inprovise::CmdChannel.open(self, config[:channel])
+  end
+
+  def helper
+    @helper ||= Inprovise::CmdHelper.get(self, config[:helper])
+  end
+
+  def disconnect!
+    @user_nodes.each_value {|n| n.disconnect! }
+    @channel.close if @channel
+    self
+  end
+
+  # generic command execution
+
+  def run(cmd, opts={})
+    log.execute("RUN: #{cmd}") if Inprovise.verbosity > 0
+    if should_run?(cmd, opts)
+      really_run(cmd, opts)
+    else
+      cached_run(cmd, opts)
+    end
+  end
+
+  def sudo(cmd, opts={})
+    log.execute("SUDO: #{cmd}") if Inprovise.verbosity > 0
+    opts = opts.merge({:sudo => true})
+    if should_run?(cmd, opts)
+      really_run(cmd, opts)
+    else
+      cached_run(cmd, opts)
+    end
+  end
+
+  # file management
+
+  def upload(from, to)
+    log.execute("UPLOAD: #{from} => #{to}") if Inprovise.verbosity > 0
+    helper.upload(from, to)
+  end
+
+  def download(from, to)
+    log.execute("DOWLOAD: #{to} <= #{from}") if Inprovise.verbosity > 0
+    helper.download(from, to)
+  end
+
+  # basic commands
+
+  def echo(arg)
+    log.execute("ECHO: #{arg}") if Inprovise.verbosity > 0
+    out = helper.echo(arg)
+    log.execute("ECHO: #{out}") if Inprovise.verbosity > 0
+    out
+  end
+
+  def env(var)
+    log.execute("ENV: #{var}") if Inprovise.verbosity > 0
+    val = helper.env(var)
+    log.execute("ENV: #{val}") if Inprovise.verbosity > 0
+    val
+  end
+
+  def cat(path)
+    log.execute("CAT: #{path}") if Inprovise.verbosity > 0
+    out = helper.cat(path)
+    log.execute("CAT: #{out}") if Inprovise.verbosity > 0
+    out
+  end
+
+  def hash_for(path)
+    log.execute("HASH_FOR: #{path}") if Inprovise.verbosity > 0
+    hsh = helper.hash_for(path)
+    log.execute("HASH_FOR: #{hsh}") if Inprovise.verbosity > 0
+    hsh
+  end
+
+  def mkdir(path)
+    log.execute("MKDIR: #{path}") if Inprovise.verbosity > 0
+    helper.mkdir(path)
+  end
+
+  def exists?(path)
+    log.execute("EXISTS?: #{path}") if Inprovise.verbosity > 0
+    rc = helper.exists?(path)
+    log.execute("EXISTS?: #{rc}") if Inprovise.verbosity > 0
+    rc
+  end
+
+  def file?(path)
+    log.execute("FILE?: #{path}") if Inprovise.verbosity > 0
+    rc = helper.file?(path)
+    log.execute("FILE?: #{rc}") if Inprovise.verbosity > 0
+    rc
+  end
+
+  def directory?(path)
+    log.execute("DIRECTORY?: #{path}") if Inprovise.verbosity > 0
+    rc = helper.directory?(path)
+    log.execute("DIRECTORY?: #{rc}") if Inprovise.verbosity > 0
+    rc
+  end
+
+  def copy(from, to)
+    log.execute("COPY: #{from} #{to}") if Inprovise.verbosity > 0
+    helper.copy(from, to)
+  end
+
+  def delete(path)
+    log.execute("DELETE: #{path}") if Inprovise.verbosity > 0
+    helper.delete(path)
+  end
+
+  def permissions(path)
+    log.execute("PERMISSIONS: #{path}") if Inprovise.verbosity > 0
+    perm = helper.permissions(path)
+    log.execute("PERMISSIONS: #{'%o' % perm}") if Inprovise.verbosity > 0
+    perm
+  end
+
+  def set_permissions(path, perm)
+    log.execute("SET_PERMISSIONS: #{path} #{'%o' % perm}") if Inprovise.verbosity > 0
+    helper.set_permissions(path, perm)
+  end
+
+  def owner(path)
+    log.execute("OWNER: #{path}") if Inprovise.verbosity > 0
+    owner = helper.owner(path)
+    log.execute("OWNER: #{owner}") if Inprovise.verbosity > 0
+    owner
+  end
+
+  def group(path)
+    log.execute("GROUP: #{path}") if Inprovise.verbosity > 0
+    group = helper.group(path)
+    log.execute("OWNER: #{group}") if Inprovise.verbosity > 0
+    group
+  end
+
+  def set_owner(path, user, group=nil)
+    log.execute("SET_OWNER: #{path} #{user}#{group ? " #{group}" : ''}") if Inprovise.verbosity > 0
+    helper.set_owner(path, user, group)
+  end
+
+  def binary_exists?(bin)
+    log.execute("BINARY_EXISTS?: #{bin}") if Inprovise.verbosity > 0
+    rc = helper.binary_exists?(bin)
+    log.execute("BINARY_EXISTS?: #{rc}") if Inprovise.verbosity > 0
+    rc
+  end
+
+  def log
+    @log ||= Inprovise::Logger.new(self, nil)
+  end
+
+  def log_to(log)
+    @log = log
+  end
+
+  def for_user(new_user, user_key=nil)
+    new_user = new_user.to_s
+    return self if self.user == new_user
+    user_key ||= new_user
+    return @user_nodes[user_key] if @user_nodes[user_key]
+    new_node = self.dup
+    new_node.prepare_connection_for_user!(new_user)
+    @user_nodes[user_key] = new_node
+    new_node
+  end
+
+  def for_dir(path)
+    user_key = "#{self.user}:#{path}"
+    return @user_nodes[user_key] if @user_nodes[user_key]
+    new_node = self.dup
+    new_node.prepare_connection_for_user!(self.user)
+  end
+
+  def prepare_connection_for_user!(new_user)
+    @user = new_user
+    @channel = nil
+    @helper = nil
+    @user_nodes = {}
+    @history = []
+    @log = Inprovise::Logger.new(self, @log.task) if @log
+  end
+
+  def to_s
+    "#{name}(#{user}@#{host})"
+  end
+
+  def safe_config
+    scfg = config.dup
+    scfg.delete :passphrase
+    scfg.delete :password
+    scfg.delete :credentials
+    scfg
+  end
+  protected :safe_config
+
+  def to_json(*a)
+    {
+      JSON.create_id  => self.class.name,
+      :data => {
+        :name => name,
+        :config => safe_config
+      }
+    }.to_json(*a)
+  end
+
+  def self.json_create(o)
+    data = o[:data]
+    new(data[:name], data[:config])
+  end
+
+  private
+
+  def cached_run(cmd, opts={})
+    cmd = "sudo #{cmd}" if opts[:sudo]
+    log.cached(cmd)
+    last_output(cmd)
+  end
+
+  def really_run(cmd, opts={})
+    exec = opts[:sudo] ? helper.sudo : helper
+    cmd = prefixed_command(cmd)
+    begin
+      output = exec.run(cmd, opts[:log])
+      @history << {cmd:cmd, output:output}
+      output
+    rescue Exception
+      raise RuntimeError, "Failed to communicate with [#{self.to_s}]"
+    end
+  end
+
+  def should_run?(cmd, opts)
+    return true unless opts[:once]
+    cmd = "sudo #{cmd}" if opts[:sudo]
+    last_output(cmd).nil?
+  end
+
+  def last_output(cmd)
+    results = @history.select {|h| h[:cmd] == cmd }
+    return nil unless results && results.size > 0
+    results.last[:output]
+  end
+
+  def prefixed_command(cmd)
+    return cmd unless config[:prefix]
+    config[:prefix] + cmd
+  end
+end

data/lib/inprovise/remote_file.rb

@@ -0,0 +1,128 @@
+# RemoteFile support for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'digest/sha1'
+require 'fileutils'
+
+class Inprovise::RemoteFile
+  attr_reader :path
+
+  def initialize(context, path)
+    @context = context
+    @path = path
+    @exists = nil
+    @permissions = nil
+    @owner = nil
+  end
+
+  def hash
+    return nil unless exists?
+    @hash ||= @context.node.hash_for(path)
+  end
+
+  def exists?
+    return @exists unless @exists.nil?
+    @exists = @context.node.exists?(path)
+  end
+
+  def directory?
+    @context.node.directory?(path)
+  end
+
+  def file?
+    @context.node.file?(path)
+  end
+
+  def content
+    @context.node.cat(path)
+  end
+
+  # doesnt check permissions or user. should it?
+  def matches?(other)
+    self.exists? && other.exists? && self.hash == other.hash
+  end
+
+  def copy_to(destination)
+    if destination.is_local?
+      download(destination)
+    else
+      duplicate(destination)
+    end
+    destination
+  end
+
+  def copy_from(destination)
+    destination.copy_to(self)
+  end
+
+  def duplicate(destination)
+    @context.copy(path, destination.path)
+    destination
+  end
+
+  def download(destination)
+    if String === destination || destination.is_local?
+      @context.download(path, String === destination ? destination : destination.path)
+    else
+      @context.copy(path, destination.path)
+    end
+    String === destination ? @context.local(destination) : destination
+  end
+
+  def upload(source)
+    if String === source || source.is_local?
+      @context.upload(String === source ? source : source.path, path)
+    else
+      @context.copy(source.path, path)
+    end
+    self
+  end
+
+  def delete!
+    @context.remove(path) if exists?
+    invalidate!
+    self
+  end
+
+  def set_permissions(mask)
+    @context.set_permissions(path, mask)
+    invalidate!
+    self
+  end
+
+  def permissions
+    @permissions ||= @context.node.permissions(path)
+  end
+
+  def set_owner(user, group=nil)
+    user ||= owner[:user]
+    @context.set_owner(path, user, group)
+    invalidate!
+    self
+  end
+
+  def owner
+    @owner ||= @context.node.owner(path)
+  end
+
+  def user
+    owner[:user]
+  end
+
+  def group
+    owner[:group]
+  end
+
+  def is_local?
+    false
+  end
+
+  private
+
+  def invalidate!
+    @permissions = nil
+    @owner = nil
+  end
+end

data/lib/inprovise/resolver.rb

@@ -0,0 +1,36 @@
+# Script dependency Resolver for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+class Inprovise::Resolver
+  attr_reader :scripts
+  def initialize(script,index=nil)
+    @script = script
+    @index = index || Inprovise::ScriptIndex.default
+    @last_seen = script
+    @scripts = [@script]
+  end
+
+  def resolve
+    begin
+      @script.dependencies.reverse.each do |d|
+        @scripts.insert(0, *Inprovise::Resolver.new(@index.get(d), @index).resolve.scripts)
+      end
+      @script.children.each do |c|
+        child = @index.get(c)
+        @scripts.concat(Inprovise::Resolver.new(child, @index).resolve.scripts) unless @scripts.include?(child)
+      end
+    rescue SystemStackError
+      raise CircularDependencyError.new
+    end
+    @scripts.uniq!
+    self
+  end
+
+  class CircularDependencyError < StandardError
+    def initialize
+      super('Circular dependecy detected')
+    end
+  end
+end

data/lib/inprovise/script.rb

@@ -0,0 +1,175 @@
+# Script base class for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'ostruct'
+
+class Inprovise::Script
+  attr_reader :name, :dependencies, :actions, :children, :user
+
+  class DSL
+    def initialize(script)
+      @script = script
+    end
+
+    def description(desc)
+      @script.description(desc)
+    end
+
+    def configuration(cfg)
+      @script.configuration(cfg)
+    end
+
+    def depends_on(*scr_names)
+      @script.depends_on(*scr_names)
+    end
+
+    def triggers(*scr_names)
+      @script.triggers(*scr_names)
+    end
+
+    def validate(&definition)
+      @script.validate(&definition)
+    end
+
+    def apply(&definition)
+      @script.apply(&definition)
+    end
+
+    def revert(&definition)
+      @script.revert(&definition)
+    end
+
+    def as(user)
+      @script.as(user)
+    end
+
+    def action(name, &definition)
+      @script.action(name, &definition)
+    end
+  end
+
+  def initialize(name)
+    @name = name
+    @description = nil
+    @configuration = nil
+    @user = nil
+    @dependencies = []
+    @children = []
+    @actions = {}
+    @commands = {}
+    @remove = nil
+  end
+
+  def description(desc=nil)
+    @description = desc if desc
+    @description
+  end
+
+  def describe
+    return [self.name] unless self.description
+    nm = [self.name]
+    self.description.split("\n").collect {|ld| "#{"%-25s" % nm.shift.to_s}\t#{ld.strip}"}
+  end
+
+  def configuration(cfg=nil)
+    @configuration = cfg if cfg
+    @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
+    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|
+      @dependencies << scr_name
+    end
+  end
+
+  def triggers(*scr_names)
+    scr_names.each do |scr_name|
+      @children << scr_name
+    end
+  end
+
+  def validate(&definition)
+    command(:validate, &definition)
+  end
+
+  def apply(&definition)
+    command(:apply, &definition)
+  end
+
+  def revert(&definition)
+    command(:revert, &definition)
+  end
+
+  def as(user)
+    @user = user
+  end
+
+  def action(name, &definition)
+    @actions[name] = definition
+  end
+
+  def command(name, &definition)
+    if block_given?
+      (@commands[name.to_sym] ||= []) << definition
+    else
+      @commands[name.to_sym] ||= []
+    end
+  end
+
+  def provides_command?(name)
+    @commands.has_key?(name.to_sym)
+  end
+
+  def to_s
+    self.name
+  end
+end
+
+Inprovise::DSL.dsl_define do
+  def script(name, &definition)
+    Inprovise.log.local("Adding provisioning script #{name}") if Inprovise.verbosity > 1
+    Inprovise.add_script(Inprovise::Script.new(name)) do |script|
+      Inprovise::Script::DSL.new(script).instance_eval(&definition)
+    end
+  end
+end

data/lib/inprovise/script_index.rb

@@ -0,0 +1,46 @@
+# Script Index for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+class Inprovise::ScriptIndex
+  attr_reader :index_name
+
+  def initialize(index_name)
+    @index_name = index_name
+    @scripts = {}
+  end
+
+  def self.default
+    @default ||= new('default')
+  end
+
+  def add(scr)
+    @scripts[scr.name] = scr
+  end
+
+  def get(scr_name)
+    scr = @scripts[scr_name]
+    raise MissingScriptError.new(index_name, scr_name) if scr.nil?
+    scr
+  end
+
+  def scripts
+    @scripts.keys
+  end
+
+  def clear!
+    @scripts = {}
+  end
+
+  class MissingScriptError < StandardError
+    def initialize(index_name, script_name)
+      @index_name = index_name
+      @script_name = script_name
+    end
+
+    def message
+      "script #{@script_name} could not be found in the index #{@index_name}"
+    end
+  end
+end