inprovise 0.2.2

data/lib/inprovise/script_runner.rb

@@ -0,0 +1,110 @@
+# Script runner for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+class Inprovise::ScriptRunner
+  COMMANDS = {apply: %w{Applying to}, revert: %w(Reverting on), validate: %w(Validating on)}
+
+  def initialize(node, script, skip_dependencies=false)
+    @node = node
+    @script = script
+    @index = Inprovise::ScriptIndex.default
+    @perform = true
+    @skip_dependencies = skip_dependencies
+    @log = Inprovise::Logger.new(@node, script)
+  end
+
+  def set_index(index)
+    @index = index
+  end
+
+  def script
+    Inprovise::Script === @script ? @script : @index.get(@script)
+  end
+
+  def scripts
+    return [script] if @skip_dependencies
+    resolver = Inprovise::Resolver.new(script, @index)
+    resolver.resolve
+    resolver.scripts
+  end
+
+  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) }
+    scrs.each do |script|
+      send(:"execute_#{command_name}", script, context)
+    end
+  end
+
+  def demonstrate(command_name, config=nil)
+    @perform = false
+    execute(command_name, config)
+    @perform = true
+  end
+
+  def execute_apply(script, context)
+    return unless should_run?(script, :apply, context)
+    exec(script, :apply, context)
+    validate!(script, context)
+  end
+
+  def execute_revert(script, context)
+    return unless should_run?(script, :revert, context)
+    exec(script, :revert, context)
+  end
+
+  def execute_validate(script, context)
+    validate!(script, context)
+  end
+
+  def should_run?(script, command_name, context)
+    return false unless script.provides_command?(command_name)
+    return true unless @perform
+    return true unless command_name == :apply || command_name == :revert
+    return true unless script.provides_command?(:validate)
+    is_present = is_valid?(script, context)
+    return !is_present if command_name == :apply
+    is_present
+  end
+
+  def validate!(script, context)
+    return true unless @perform
+    return unless script.provides_command?(:validate)
+    return if is_valid?(script, context)
+    raise ValidationFailureError.new(@node, script)
+  end
+
+  def is_valid?(script, context)
+    results = exec(script, :validate, context)
+    rc = results.all?
+    context.log.command("validate -> #{rc}") if Inprovise.verbosity > 0
+    rc
+  end
+
+  def exec(script, command_name, context)
+    cmds = script.command(command_name)
+    context = context.for_user(script.user) if script.user
+    context.log.set_task(script)
+    context.log.command(command_name)
+    context.script = script
+    cmds.map {|cmd| context.exec(cmd) }
+  end
+
+  class ValidationFailureError < StandardError
+    def initialize(node, script)
+      @node = node
+      @script = script
+    end
+
+    def message
+      "Script #{@script.name} failed validation on #{@node.to_s}"
+    end
+  end
+end

data/lib/inprovise/sniff.rb

@@ -0,0 +1,46 @@
+# Sniffer main module for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+module Inprovise::Sniffer
+
+  ROOT_SCRIPT = 'sniffers'
+
+  class << self
+
+    def sniffers
+      @sniffers ||= Inprovise::ScriptIndex.new('sniffers')
+    end
+
+    def add_sniffer(name, &definition)
+      Inprovise.log.local("Adding sniffer script #{name}") if Inprovise.verbosity > 2
+      script = Inprovise::Script.new(name)
+      Inprovise::Script::DSL.new(script).instance_eval(&definition) if block_given?
+      sniffers.add(script)
+      script
+    end
+    private :add_sniffer
+
+    def define(name, auto_trigger=true, &definition)
+      script = add_sniffer("sniff[#{name}]", &definition)
+      sniffers.get(ROOT_SCRIPT).triggers(script.name) if auto_trigger
+      script
+    end
+
+    def run_sniffers_for(node)
+      node.config[:attributes] ||= {}
+      runner = Inprovise::ScriptRunner.new(node, 'sniffers')
+      runner.set_index(@sniffers)
+      runner.execute(:apply)
+    end
+
+  end
+
+  # add root sniffer script
+  # (doesn't do anything by itself except provide a container triggering all specific sniffers)
+  add_sniffer(ROOT_SCRIPT)
+
+end
+
+require_relative './sniffer/platform.rb'

data/lib/inprovise/sniffer/linux.rb

@@ -0,0 +1,64 @@
+# Linux platform sniffer for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+Inprovise::Sniffer.define('linux', false) do
+
+  action('main') do |attrs|
+    attrs[:machine] = run('uname -m').chomp
+    if remote('/etc/os-release').exists?
+      trigger 'sniff[linux]:os-release', attrs
+    elsif remote('/etc/redhat-release').exists?
+      trigger 'sniff[linux]:redhat-release', attrs
+    elsif remote('/etc/SuSE-release').exists?
+      trigger 'sniff[linux]:suse-release', attrs
+    end
+    attrs[:pkgman] = case attrs[:os_distro]
+                     when 'fedora', 'centos', 'rhel'
+                       binary_exists?('dnf') ? 'dnf' : 'yum'
+                     when /suse/
+                       'zypper'
+                     end
+  end
+
+  action('os-release') do |attrs|
+    data = remote('/etc/os-release').content.split("\n").collect {|l| l.strip }
+    vars = data.inject({}) do |hash, line|
+      unless line.empty? || line.start_with?('#') || !(line =~ /[^=]+=.*/)
+        var, val = line.split('=')
+        hash[var] = val.strip.gsub(/(\A")|("\Z)/, '')
+      end
+      hash
+    end
+    attrs[:os_distro] = vars['ID'].downcase
+    attrs[:os_version] = vars['VERSION_ID']
+    if attrs[:os_distro] == 'centos' && remote('/etc/centos-release').exists?
+      data = remote('/etc/centos-release').content.split("\n").collect {|l| l.strip }
+      data.each do |line|
+        if line =~ /\s+release\s+(\d+)\.(\d+).*/
+          attrs[:os_version] = "#{$1}.#{$2}"
+        end
+      end
+    end
+  end
+
+  action('redhat-release') do |attrs|
+    data = remote('/etc/redhat-release').content.split("\n").collect {|l| l.strip }
+    data.each do |line|
+      if line =~ /\A(.+)\s+release\s+(\d+)(\.(\d+))?/
+        attrs[:os_version] = "#{$2}.#{$4 || '0'}"
+        tmpos = $1.strip.downcase
+        attrs[:os_distro] = case tmpos
+                              when /fedora/
+                                'fedora'
+                              when /red\s+hat/
+                                'rhel'
+                              when /centos/
+                                'centos'
+                              end
+      end
+    end
+  end
+
+end

data/lib/inprovise/sniffer/platform.rb

@@ -0,0 +1,46 @@
+# Platform sniffer for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+Inprovise::Sniffer.define('platform') do
+
+  action('helper') do |attrs|
+    # determin the best CmdHelper if not user defined
+    attrs[:helper] = case attrs[:os]
+                     when 'linux'
+                       'linux'
+                     when 'windows'
+                       # check for Cygwin environment
+                       ostype = node.channel.run('echo $OSTYPE').strip
+                       # configure the Linux command helper here first;
+                       # this way we can use the full context functionality from now on
+                       node.config[:helper] = (/cygwin/i =~ ostype ? 'cygwin' : 'windows')
+                     end unless attrs[:helper]
+  end
+
+  apply do
+    attrs = {}
+    os = node.channel.run('echo %OS%').chomp
+    os = node.channel.run('echo $OS').chomp if os == '%OS%'
+    os = node.channel.run('uname -o').chomp if os.empty?
+    attrs[:os] = case os
+                   when /windows/i
+                   'windows'
+                   when /linux/i
+                   'linux'
+                   else
+                   'unknown'
+                 end
+    # determin and initialize helper
+    trigger 'sniff[platform]:helper', attrs
+    # detect detailed platform props
+    trigger "sniff[#{attrs[:os]}]:main", attrs
+    (node.config[:attributes][:platform] ||= {}).merge!(attrs)
+  end
+
+end
+
+require_relative './windows.rb'
+require_relative './linux.rb'
+require_relative './unknown.rb'

data/lib/inprovise/sniffer/unknown.rb

@@ -0,0 +1,11 @@
+# Unknown platform sniffer for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+Inprovise::Sniffer.define('unknown', false) do
+
+  action('main') do |attrs|
+  end
+
+end

data/lib/inprovise/sniffer/windows.rb

@@ -0,0 +1,32 @@
+# Windows platform sniffer for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+Inprovise::Sniffer.define('windows', false) do
+
+  action('main') do |attrs|
+    attrs[:machine] = env('PROCESSOR_ARCHITECTURE').chomp =~ /amd64/i ? 'x86_64' : 'x86'
+    osver = run('cmd /c ver').strip
+    if /\[version\s+(\d+)\.(\d+)\.(\d+)\]/i =~ osver
+      attrs[:os_version] = case $1
+                               when '5'
+                               'xp'
+                               when '6'
+                                 case $2
+                                   when '1'
+                                     '7'
+                                   when '2'
+                                     '8'
+                                   when '3'
+                                     '8.1'
+                                 end
+                               when '10'
+                                 '10'
+                               else
+                                 $1
+                             end
+    end
+  end
+
+end

data/lib/inprovise/template/inprovise.rb.erb

@@ -0,0 +1,92 @@
+# Scheme template for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+# include 'another_scheme.rb'
+
+# script 'script' do
+#
+#   description 'description'
+#
+#   configuration <data>
+#
+#   action('action1') {  }
+#   action('action2')  { }
+#
+#   apply do
+#
+#   end
+#
+#   revert do
+#
+#   end
+#
+#   validate do
+#
+#   end
+# end
+#
+#
+# All blocks (action,apply,revert,validate,file props,file block) execute in a special context providing the
+# following methods:
+#
+# node                                              current node
+#
+# config                                            current (consolidated, transient) config
+#
+# as 'user' do ... end                              creates a nested execution context where all remote commands
+#                                                   will be executed for the given user
+#
+# in_dir 'path' do ... end                          creates a nested execution context where all remote commands
+#                                                   will be executed using the given path as working directory
+#
+# trigger 'script:action'[,*args]                   runs specified action code blocks
+#
+# run 'command'[, {}]                               execute command on current node over SSH connection
+#                                                   options:
+#                                                     :once => true
+#                                                       run command only once (from whatever script executes it first)
+#                                                     :log => true
+#                                                       force logging SSH commands and output
+#
+# run_local 'command'                               execute command locally
+#
+# log 'msg'                                         log a message
+#
+# sudo 'command'[, {}]                              execute command on current node over SSH connection using 'sudo'
+#                                                   options: see 'run'
+#
+# env 'var'                                         returns value of environment variable on current node
+#
+# upload '/from/local/path', '/to/remote/path'      up-/download files using SFTP connection for current node
+# download '/from/remote/path', '/to/local/path'
+#
+# local('/local/path')                              creates a local/remote file object providing the following
+# remote('/remote/path')                            methods:
+#                         .hash                             returns an SHA1 hash as hex string
+#                         .exists?
+#                         .file?
+#                         .directory?
+#                         .content
+#                         .matches?(other_file)
+#                         .copy_to(dest_file)
+#                         .copy_from(src_file)
+#                         .delete!
+#                         .permissions
+#                         .set_permissions
+#                         .user
+#                         .group
+#                         .set_owner('user'[,'group'])
+#                         .is_local?
+#
+# mkdir '/remote/path'                              create directory(-ies) on current node
+#
+# binary_exists?('bin-name')
+#
+# template('/local/file')                           creates a template object for the specified (ERB) template file
+#                                                   providing 2 rendering options
+#                         .render(locals ={})                 returns rendered result string
+#                         .render_to_tempfile(locals = {})    returns path of tempfile containing rendered result
+#
+

data/lib/inprovise/template.rb

@@ -0,0 +1,38 @@
+# Template support for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'erb'
+require 'tilt'
+require 'tempfile'
+
+class Inprovise::Template
+  def initialize(path, context = nil)
+    @context = context || Object.new
+    @path = resolve(path)
+    @template = @path.respond_to?(:call) ? Tilt['erb'].new(&@path) : Tilt.new(@path)
+  end
+
+  def render(locals={})
+    @template.render(@context, locals)
+  end
+
+  def render_to_tempfile(locals={})
+    basename = @path.respond_to?(:call) ? 'inprovise-inline-tpl' : File.basename(@path).gsub('.', '-')
+    file = Tempfile.new(basename)
+    file.write render(locals)
+    file.close
+    file.path
+  end
+
+  private
+
+  def resolve(path)
+    if path.respond_to?(:call) || path =~ /^\//
+      path
+    else
+      File.join(Inprovise.root, path)
+    end
+  end
+end

data/lib/inprovise/trigger_runner.rb

@@ -0,0 +1,36 @@
+# Trigger runner for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+class Inprovise::TriggerRunner
+  def initialize(node, action_ref_with_args)
+    @node = node
+    @action_ref, @args = *parse_action_ref(action_ref_with_args)
+    @log = Inprovise::Logger.new(@node, @action_ref)
+    @index = Inprovise::ScriptIndex.default
+  end
+
+  def set_index(index)
+    @index = index
+  end
+
+  def execute(_, config=nil)
+    Inprovise.log.local("Triggering #{@action_ref} for #{@node.to_s}")
+    Inprovise::ExecutionContext.new(@node, @log, @index, config).trigger(@action_ref, *@args)
+  end
+
+  def demonstrate(_, config=nil)
+    Inprovise::MockExecutionContext.new(@node, @log, @index, config).trigger(@action_ref, *@args)
+  end
+
+  private
+
+  def parse_action_ref(action_ref_with_args)
+    matches = action_ref_with_args.match(/([\w\-\:]+?)(\[([\w\-\,]+?)\])/)
+    return [action_ref_with_args,[]] unless matches
+    action_ref = matches[1]
+    args = matches[3].split(',').map(&:strip)
+    [action_ref, args]
+  end
+end

data/lib/inprovise/version.rb

@@ -0,0 +1,10 @@
+# Version definition for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+module Inprovise
+
+  VERSION = '0.2.2'
+
+end

data/lib/inprovise.rb

@@ -0,0 +1,145 @@
+# Main loader for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'rubygems'
+require 'colored'
+
+module Inprovise
+
+  INFRA_FILE = 'infra.json'
+  RC_FILE = 'rigrc'
+  DEFAULT_SCHEME = 'inprovise.rb'
+
+  class << self
+    def verbosity
+      @verbose ||= 0
+    end
+
+    def verbosity=(val)
+      @verbose = val.to_i
+    end
+
+    def show_backtrace
+      @show_backtrace ||= false
+    end
+
+    def show_backtrace=(f)
+      @show_backtrace = (f == true)
+    end
+
+    def sequential
+      @sequential ||= false
+    end
+
+    def sequential=(f)
+      @sequential = (f == true)
+    end
+
+    def demonstrate
+      @demonstrate ||= false
+    end
+
+    def demonstrate=(f)
+      @demonstrate = (f == true)
+    end
+
+    def skip_dependencies
+      @skip_dependencies ||= false
+    end
+
+    def skip_dependencies=(f)
+      @skip_dependencies = (f == true)
+    end
+
+    def infra
+      @infra ||= (ENV['INPROVISE_INFRA'] || find_infra)
+    end
+
+    def root
+      @root ||= File.dirname(infra)
+    end
+
+    def default_scheme
+      ENV['INPROVISE_SCHEME'] || Inprovise::DEFAULT_SCHEME
+    end
+
+    def schemes
+      @schemes ||= []
+    end
+
+    def loaded?(scheme)
+      schemes.include?(File.expand_path(scheme, root))
+    end
+
+    def log
+      @log ||= Inprovise::Logger.new('Local', 'cli')
+    end
+
+    def add_script(script)
+      yield(script) if block_given?
+      Inprovise::ScriptIndex.default.add(script)
+      script
+    end
+
+    private
+
+    def find_infra
+      curpath = File.expand_path('.')
+      begin
+        # check if this is where the infra file lives
+        if File.file?(File.join(curpath, Inprovise::INFRA_FILE))
+          return File.join(curpath, Inprovise::INFRA_FILE)
+        end
+        # not found yet, move one dir up until we reach the root
+        curpath = File.expand_path(File.join(curpath, '..'))
+      end while !(curpath =~ /^(#{File::SEPARATOR}|.:#{File::SEPARATOR})$/)
+      INFRA_FILE
+    end
+  end
+
+  module DSL
+
+    def self.singleton_class
+      class << self; self; end
+    end unless self.respond_to?(:singleton_class)
+
+    singleton_class.class_eval do
+      def dsl_define(*args, &block)
+        Inprovise::DSL.singleton_class.class_eval(*args, &block)
+      end
+    end
+
+    dsl_define do
+      def include(path)
+        path = File.expand_path(path, Inprovise.root)
+        unless Inprovise.schemes.include?(path)
+          Inprovise.schemes << path
+          Inprovise.log.local("Loading provisioning scheme #{path}") if Inprovise.verbosity > 0
+          Inprovise::DSL.module_eval(File.read(path), path)
+        end
+      end
+    end
+
+  end
+
+end
+
+require_relative './inprovise/version'
+require_relative './inprovise/logger'
+require_relative './inprovise/cmd_channel'
+require_relative './inprovise/cmd_helper'
+require_relative './inprovise/script'
+require_relative './inprovise/script_index'
+require_relative './inprovise/local_file'
+require_relative './inprovise/remote_file'
+require_relative './inprovise/script_runner'
+require_relative './inprovise/trigger_runner'
+require_relative './inprovise/resolver'
+require_relative './inprovise/template'
+require_relative './inprovise/execution_context'
+require_relative './inprovise/infra'
+require_relative './inprovise/sniff'
+require_relative './inprovise/control'
+require_relative './inprovise/cli'