itamae-mitsurin 0.4 → 0.7

data/test/test_itamae-mitsurin/test_cli.rb

@@ -0,0 +1,88 @@
+require 'itamae-mitsurin'
+require 'thor'
+require 'test/unit'
+include Test::Unit::TestCase
+
+module TestItamaeMitsurin
+  class TestCLI < Thor
+
+    class_option :log_level, type: :string, aliases: ['-l'], default: 'info'
+    class_option :color, type: :boolean, default: true
+    class_option :config, type: :string, aliases: ['-c']
+
+    def initialize(*)
+      super
+
+      ItamaeMitsurin.logger.level = ::Logger.const_get(options[:log_level].upcase)
+      ItamaeMitsurin.logger.formatter.colored = options[:color]
+    end
+
+    def self.define_exec_options
+      option :recipe_graph, type: :string, desc: "[EXPERIMENTAL] Write recipe dependency graph in DOT", banner: "PATH"
+      option :node_json, type: :string, aliases: ['-j']
+      option :node_yaml, type: :string, aliases: ['-y']
+      option :dry_run, type: :boolean, aliases: ['-n']
+      option :shell, type: :string, default: "/bin/sh"
+      option :ohai, type: :boolean, default: false, desc: "This option is DEPRECATED and will be unavailable."
+      option :profile, type: :string, desc: "[EXPERIMENTAL] Save profiling data", banner: "PATH"
+    end
+
+    desc "local RECIPE [RECIPE...]", "Run Itamae locally"
+    define_exec_options
+    def local(*recipe_files)
+      if recipe_files.empty?
+        raise "Please specify recipe files."
+      end
+
+      Runner.run(recipe_files, :local, options)
+    end
+
+    desc "ssh RECIPE [RECIPE...]", "Run Itamae via ssh"
+    define_exec_options
+    option :host, type: :string, aliases: ['-h']
+    option :user, type: :string, aliases: ['-u']
+    option :key, type: :string, aliases: ['-i']
+    option :port, type: :numeric, aliases: ['-p']
+    option :vagrant, type: :boolean, default: false
+    option :ask_password, type: :boolean, default: false
+    option :sudo, type: :boolean, default: true
+    def ssh(*recipe_files)
+      if recipe_files.empty?
+        raise "Please specify recipe files."
+      end
+
+      unless options[:host] || options[:vagrant]
+        raise "Please set '-h <hostname>' or '--vagrant'"
+      end
+
+      Runner.run(recipe_files, :ssh, options)
+    end
+
+    desc "docker RECIPE [RECIPE...]", "Create Docker image"
+    define_exec_options
+    option :image, type: :string, desc: "This option or 'container' option is required."
+    option :container, type: :string, desc: "This option or 'image' option is required."
+    option :tls_verify_peer, type: :boolean, default: true
+    def docker(*recipe_files)
+      if recipe_files.empty?
+        raise "Please specify recipe files."
+      end
+
+      Runner.run(recipe_files, :docker, options)
+    end
+
+    desc "version", "Print version"
+    def version
+      puts "itamae-mitsurin v#{ItamaeMitsurin::VERSION}"
+    end
+
+    private
+    def options
+      @itamae_options ||= super.dup.tap do |options|
+        if config = options[:config]
+          options.merge!(YAML.load_file(config))
+        end
+      end
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_definition.rb

@@ -0,0 +1,40 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  class Definition < Resource::Base
+    class << self
+      attr_accessor :definition_block
+      attr_accessor :defined_in_recipe
+
+      def create_class(name, params, defined_in_recipe, &block)
+        Class.new(self).tap do |klass|
+          klass.definition_block = block
+          klass.defined_in_recipe = defined_in_recipe
+
+          klass.define_attribute :action, default: :run
+          params.each_pair do |key, value|
+            klass.define_attribute key.to_sym, type: Object, default: value
+          end
+        end
+      end
+    end
+
+    def initialize(*args)
+      super
+
+      r = Recipe::RecipeFromDefinition.new(
+        runner,
+        self.class.defined_in_recipe.path,
+      )
+      recipe.children << r
+
+      r.definition = self
+      r.load(params: @attributes.merge(name: resource_name))
+    end
+
+    def run(*args)
+      # nothing
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/test_ext.rb

@@ -0,0 +1 @@
+require 'itamae-mitsurin/ext/specinfra'

data/test/test_itamae-mitsurin/test_handler.rb

@@ -0,0 +1,21 @@
+require 'itamae-mitsurin/handler/base'
+
+module ItamaeMitsurin
+  module Handler
+    def self.from_type(type)
+      first_time = true
+
+      class_name = type.split('_').map(&:capitalize).join
+      self.const_get(class_name)
+    rescue NameError
+      require "itamae-mitsurin/handler/#{type}"
+
+      if first_time
+        first_time = false
+        retry
+      else
+        raise
+      end
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_handler_proxy.rb

@@ -0,0 +1,38 @@
+module ItamaeMitsurin
+  class HandlerProxy
+    def initialize
+      @instances = []
+    end
+
+    def register_instance(instance)
+      @instances << instance
+    end
+
+    def event(*args, &block)
+      if block_given?
+        _event_with_block(*args, &block)
+      else
+        _event(*args)
+      end
+    end
+
+    private
+
+    def _event(*args)
+      @instances.each do |i|
+        i.event(*args)
+      end
+    end
+
+    def _event_with_block(event_name, *args, &block)
+      event("#{event_name}_started".to_sym, *args)
+      block.call
+    rescue
+      event("#{event_name}_failed".to_sym, *args)
+      raise
+    else
+      event("#{event_name}_completed".to_sym, *args)
+    end
+  end
+end
+

data/test/test_itamae-mitsurin/test_logger.rb

@@ -0,0 +1,124 @@
+require 'itamae-mitsurin'
+require 'logger'
+require 'ansi/code'
+
+module ItamaeMitsurin
+  module Logger
+    module Helper
+      def with_indent
+        indent
+        yield
+      ensure
+        outdent
+      end
+
+      def with_indent_if(condition, &block)
+        if condition
+          with_indent(&block)
+        else
+          block.call
+        end
+      end
+
+      def indent
+        self.indent_depth += 1
+      end
+
+      def outdent
+        self.indent_depth -= 1
+        self.indent_depth = 0 if self.indent_depth < 0
+      end
+
+      def indent_depth
+        @indent_depth ||= 0
+      end
+
+      def indent_depth=(val)
+        @indent_depth = val
+      end
+
+      def color(code, &block)
+        if self.formatter.respond_to?(:color)
+          self.formatter.color(code, &block)
+        else
+          block.call
+        end
+      end
+
+      %w!debug info warn error fatal unknown!.each do |level|
+        module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          def #{level}(msg)
+            super("  " * indent_depth + msg)
+          end
+        EOC
+      end
+    end
+
+    class Formatter
+      attr_accessor :colored
+
+      def call(severity, datetime, progname, msg)
+        log = "%s : %s\n" % ["%5s" % severity, msg2str(msg)]
+        if colored
+          colorize(log, severity)
+        else
+          log
+        end
+      end
+
+      def color(code)
+        prev_color = @color
+        @color = code
+        yield
+      ensure
+        @color = prev_color
+      end
+
+      private
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{ msg.message } (#{ msg.class })\n" <<
+          (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+
+      def colorize(str, severity)
+        if @color
+          color_code = @color
+        else
+          color_code = case severity
+                       when "INFO"
+                         :clear
+                       when "WARN"
+                         :magenta
+                       when "ERROR"
+                         :red
+                       else
+                         :clear
+                       end
+        end
+        ANSI.public_send(color_code) { str }
+      end
+    end
+  end
+
+  @logger = ::Logger.new($stdout).tap do |l|
+    l.formatter = ItamaeMitsurin::Logger::Formatter.new
+  end.extend(ItamaeMitsurin::Logger::Helper)
+
+  class << self
+    def logger
+      @logger
+    end
+
+    def logger=(l)
+      @logger = l.extend(ItamaeMitsurin::Logger::Helper)
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_mitsurin.rb

@@ -0,0 +1,14 @@
+require 'itamae-mitsurin/version'
+require 'itamae-mitsurin/mitsurin/cli'
+require 'itamae-mitsurin/mitsurin/creators'
+require 'aws-sdk'
+#require 'itamae-mitsurin/mitsurin/itamae_task'
+#require 'itamae-mitsurin/mitsurin/serverspec_task'
+#require 'itamae-mitsurin/mitsurin/itamae_with_git_task'
+
+
+module ItamaeMitsurin
+  module Mitsurin
+  # TODO
+  end
+end

data/test/test_itamae-mitsurin/test_node.rb

@@ -0,0 +1,74 @@
+require 'itamae-mitsurin'
+require 'hashie'
+require 'json'
+require 'schash'
+
+module ItamaeMitsurin
+  class Node
+    ValidationError = Class.new(StandardError)
+
+    attr_reader :mash
+
+    def initialize(hash, backend)
+      @mash = Hashie::Mash.new(hash)
+      @backend = backend
+    end
+
+    def reverse_merge(other_hash)
+      self.class.new(_reverse_merge(other_hash), @backend)
+    end
+
+    def reverse_merge!(other_hash)
+      @mash.replace(_reverse_merge(other_hash))
+    end
+
+    def [](key)
+      if @mash.has_key?(key)
+        @mash[key]
+      else
+        fetch_inventory_value(key)
+      end
+    end
+
+    def validate!(&block)
+      errors = Schash::Validator.new(&block).validate(@mash)
+      unless errors.empty?
+        errors.each do |error|
+          ItamaeMitsurin.logger.error "'#{error.position.join('->')}' #{error.message}"
+        end
+        raise ValidationError
+      end
+    end
+
+    private
+
+    def _reverse_merge(other_hash)
+      Hashie::Mash.new(other_hash).merge(@mash)
+    end
+
+    def method_missing(method, *args)
+      if @mash.respond_to?(method)
+        return @mash.public_send(method, *args)
+      elsif args.empty? && value = fetch_inventory_value(method)
+        return value
+      end
+
+      super
+    end
+
+    def respond_to?(method, priv = false)
+      @mash.respond_to?(method, priv) || super
+    end
+
+    def fetch_inventory_value(key)
+      value = @backend.host_inventory[key]
+      if value.is_a?(Hash)
+        value = Hashie::Mash.new(value)
+      end
+
+      value
+    rescue NotImplementedError, NameError
+      nil
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_notification.rb

@@ -0,0 +1,46 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  class Notification < Struct.new(:defined_in_resource, :action, :target_resource_desc, :timing)
+    def self.create(*args)
+      self.new(*args).tap(&:validate!)
+    end
+
+    def resource
+      runner.children.find_resource_by_description(target_resource_desc)
+    end
+
+    def run
+      action_resource.run(action)
+    end
+
+    def action_resource
+      resource
+    end
+
+    def runner
+      defined_in_resource.recipe.runner
+    end
+
+    def delayed?
+      [:delay, :delayed].include?(timing)
+    end
+
+    def immediately?
+      timing == :immediately
+    end
+
+    def validate!
+      unless [:delay, :delayed, :immediately].include?(timing)
+        ItamaeMitsurin.logger.error "'#{timing}' is not valid notification timing. (Valid option is delayed or immediately)"
+        abort
+      end
+    end
+  end
+
+  class Subscription < Notification
+    def action_resource
+      defined_in_resource
+    end
+  end
+end