itamae-mitsurin 0.1

data/lib/itamae/mitsurin/serverspec_task.rb

@@ -0,0 +1,110 @@
+require 'serverspec'
+require 'rake'
+require 'rspec/core/rake_task'
+require 'json'
+require 'simple_color'
+include Rake::DSL if defined? Rake::DSL
+
+module Itamae
+  module Mitsurin
+    class ServerspecTask
+
+      class << self
+
+        task :spec => 'spec:all'
+        task :default => :spec
+
+        def self.get_roles(node_file)
+          roles = []
+          JSON.parse(File.read(node_file))['run_list'].each do |role|
+            roles << role.gsub(/role\[(.+)\]/, '\1') if /role\[(.+)\]/ === role
+          end
+          roles
+        end
+
+        def self.get_recipes(role)
+          recipes = []
+          JSON.parse(File.read("roles/#{role}.json"))['run_list'].each do |recipe|
+            if /recipe\[(.+)::(.+)\]/ === recipe
+              recipes << {recipe.gsub(/recipe\[(.+)::(.+)\]/, '\1') => recipe.gsub(/recipe\[(.+)::(.+)\]/, '\2')}
+            else
+              recipes << {recipe.gsub(/recipe\[(.+)\]/, '\1') => nil}
+            end
+          end
+          recipes
+        end
+
+        def self.get_node_recipes(node_file)
+          recipes = []
+          JSON.parse(File.read(node_file))['run_list'].each do |recipe|
+            if /recipe\[(.+)::(.+)\]/ === recipe
+              recipes << {recipe.gsub(/recipe\[(.+)::(.+)\]/, '\1') => recipe.gsub(/recipe\[(.+)::(.+)\]/, '\2')}
+            else
+              recipes << {recipe.gsub(/recipe\[(.+)\]/, '\1') => nil} unless /role\[(.+)\]/ === recipe
+            end
+          end
+          recipes
+        end
+
+        namespace :spec do
+          all = []
+          Dir.glob("tmp-nodes/**/*.json").each do |node_file|
+
+            file_name = File.basename(node_file, '.json')
+            node_attr = JSON.parse(File.read(node_file), symbolize_names: true)
+            desc "Run to #{file_name}"
+
+            begin
+              recipes = []
+              get_roles(node_file).each do |role|
+                recipes << get_recipes(role)
+              end
+              get_node_recipes(node_file).each do |recipe|
+                recipes << recipe
+              end
+            rescue Exception => e
+              puts e.class.to_s + ", " + e.backtrace[0].to_s
+              puts "nodefile or role error, nodefile:#{node_file} reason:#{e.message}"
+              exit 1
+            else
+              recipes << {'_base' => nil}
+              recipes.flatten!
+            end
+
+            node_name = node_attr[:environments][:hostname]
+            ssh_user = node_attr[:environments][:ssh_user]
+            ssh_password = node_attr[:environments][:ssh_password]
+            ssh_port = node_attr[:environments][:ssh_port]
+            ssh_key = node_attr[:environments][:ssh_key]
+
+            node_short = node_name.split(".")[0]
+            all << node_short
+
+            desc "Run spec to #{file_name}"
+            RSpec::Core::RakeTask.new(node_short.to_sym) do |t|
+              ENV['TARGET_HOST'] = node_name
+              ENV['NODE_FILE'] = node_file
+              ENV['SSH_PASSWORD'] = ssh_password
+              ENV['SSH_KEY'] = "keys/#{ssh_key}"
+
+              specs = []
+              spec_recips = []
+              recipes.each {|hash|
+                specs << hash.keys.join
+                spec_recips << hash.values.join unless hash.values.join.empty?
+              }
+
+              t.pattern = "site-cookbooks/**/\{#{specs.join(',')}\}/spec/\{default,#{spec_recips.join(',')}\}_spec.rb"
+              t.fail_on_error = true
+              color = SimpleColor.new
+              color.echos(:red, "Run Serverspec to #{node_name}")
+              color.echos(:green, "Run List to #{specs.uniq.sort.join(", ")}")
+            end
+            task :all => all
+            task :default => :all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/itamae/mitsurin/version.rb

@@ -0,0 +1,5 @@
+module Itamae
+  module Mitsurin
+  VERSION = File.read(File.expand_path("../version.txt", __FILE__)).strip
+  end
+end

data/lib/itamae/mitsurin/version.txt

@@ -0,0 +1 @@
+0.1

data/lib/itamae/node.rb

@@ -0,0 +1,74 @@
+require 'itamae'
+require 'hashie'
+require 'json'
+require 'schash'
+
+module Itamae
+  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|
+          Itamae.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/lib/itamae/notification.rb

@@ -0,0 +1,46 @@
+require 'itamae'
+
+module Itamae
+  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)
+        Itamae.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

data/lib/itamae/recipe.rb

@@ -0,0 +1,171 @@
+require 'itamae'
+
+module Itamae
+  class Recipe
+    NotFoundError = Class.new(StandardError)
+
+    attr_reader :path
+    attr_reader :runner
+    attr_reader :children
+    attr_reader :delayed_notifications
+
+    class << self
+      def find_recipe_in_gem(recipe)
+        plugin_name, recipe_file = recipe.split('::', 2)
+        recipe_file = recipe_file.gsub("::", "/") if recipe_file
+
+        gem_name = "itamae-plugin-recipe-#{plugin_name}"
+        begin
+          gem gem_name
+        rescue LoadError
+        end
+        spec = Gem.loaded_specs.values.find do |spec|
+          spec.name == gem_name
+        end
+
+        return nil unless spec
+
+        candidate_files = []
+        if recipe_file
+          recipe_file += '.rb' unless recipe_file.end_with?('.rb')
+          candidate_files << "#{plugin_name}/#{recipe_file}"
+        else
+          candidate_files << "#{plugin_name}/default.rb"
+          candidate_files << "#{plugin_name}.rb"
+        end
+
+        candidate_files.map do |file|
+          File.join(spec.lib_dirs_glob, 'itamae', 'plugin', 'recipe', file)
+        end.find do |path|
+          File.exist?(path)
+        end
+      end
+    end
+
+    def initialize(runner, path)
+      @runner = runner
+      @path = path
+      @delayed_notifications = []
+      @children = RecipeChildren.new
+    end
+
+    def dir
+      ::File.dirname(@path)
+    end
+
+    def load(vars = {})
+      context = EvalContext.new(self, vars)
+      context.instance_eval(File.read(path), path, 1)
+    end
+
+    def run
+      show_banner
+
+      @runner.handler.event(:recipe, path: @path) do
+        Itamae.logger.with_indent do
+          @children.run
+          run_delayed_notifications
+        end
+      end
+    end
+
+    private
+
+    def run_delayed_notifications
+      @delayed_notifications.uniq! do |notification|
+        [notification.action, notification.action_resource]
+      end
+
+      while notification = @delayed_notifications.shift
+        notification.run
+      end
+    end
+
+    def show_banner
+      Itamae.logger.info "Recipe: #{@path}"
+    end
+
+    class EvalContext
+      def initialize(recipe, vars)
+        @recipe = recipe
+
+        vars.each do |k, v|
+          define_singleton_method(k) { v }
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        Resource.get_resource_class(method)
+        true
+      rescue NameError
+        false
+      end
+
+      def method_missing(*args, &block)
+        super unless args.size == 2
+
+        method, name = args
+        begin
+          klass = Resource.get_resource_class(method)
+        rescue NameError
+          super
+        end
+
+        resource = klass.new(@recipe, name, &block)
+        @recipe.children << resource
+      end
+
+      def define(name, params = {}, &block)
+        Resource.define_resource(name, Definition.create_class(name, params, @recipe, &block))
+      end
+
+      def include_recipe(target)
+        expanded_path = ::File.expand_path(target, File.dirname(@recipe.path))
+        expanded_path = ::File.join(expanded_path, 'default.rb') if ::Dir.exists?(expanded_path)
+        expanded_path.concat('.rb') unless expanded_path.end_with?('.rb')
+        candidate_paths = [expanded_path, Recipe.find_recipe_in_gem(target)].compact
+        path = candidate_paths.find {|path| File.exist?(path) }
+
+        unless path
+          raise NotFoundError, "Recipe not found. (#{target})"
+        end
+
+        if runner.children.find_recipe_by_path(path)
+          Itamae.logger.debug "Recipe, #{path}, is skipped because it is already included"
+          return
+        end
+
+        recipe = Recipe.new(runner, path)
+        @recipe.children << recipe
+        recipe.load
+      end
+
+      def node
+        runner.node
+      end
+
+      def runner
+        @recipe.runner
+      end
+
+      def run_command(*args)
+        runner.backend.run_command(*args)
+      end
+    end
+
+    class RecipeFromDefinition < Recipe
+      attr_accessor :definition
+
+      def load(vars = {})
+        context = EvalContext.new(self, vars)
+        context.instance_eval(&@definition.class.definition_block)
+      end
+
+      private
+
+      def show_banner
+        Itamae.logger.debug "#{@definition.resource_type}[#{@definition.resource_name}]"
+      end
+    end
+  end
+end

data/lib/itamae/recipe_children.rb

@@ -0,0 +1,86 @@
+module Itamae
+  class RecipeChildren < Array
+    NotFoundError = Class.new(StandardError)
+
+    def find_resource_by_description(desc)
+      # desc is like 'resource_type[name]'
+      resources.find do |resource|
+        type, name = Itamae::Resource.parse_description(desc)
+        resource.resource_type == type && resource.resource_name == name
+      end.tap do |resource|
+        unless resource
+          raise NotFoundError, "'#{desc}' resource is not found."
+        end
+      end
+    end
+
+    def subscribing(target)
+      resources.map do |resource|
+        resource.subscriptions.select do |subscription|
+          subscription.resource == target
+        end
+      end.flatten
+    end
+
+    def find_recipe_by_path(path)
+      recipes.find do |recipe|
+        recipe.path == path
+      end
+    end
+
+    def resources
+      self.map do |item|
+        case item
+        when Resource::Base
+          item
+        when Recipe
+          item.children.resources
+        end
+      end.flatten
+    end
+
+    def recipes(options = {})
+      options = {recursive: true}.merge(options)
+
+      self.select do |item|
+        item.is_a?(Recipe)
+      end.map do |recipe|
+        if options[:recursive]
+          [recipe] + recipe.children.recipes
+        else
+          recipe
+        end
+      end.flatten
+    end
+
+    def run
+      self.each do |resource|
+        resource.run
+      end
+    end
+
+    # returns dependencies graph in DOT
+    def dependency_in_dot
+      result = ""
+      result << "digraph recipes {\n"
+      result << "  rankdir=LR;\n"
+      result << _dependency_in_dot
+      result << "}"
+
+      result
+    end
+
+    def _dependency_in_dot
+      result = ""
+
+      recipes(recursive: false).each do |recipe|
+        recipe.children.recipes(recursive: false).each do |child_recipe|
+          result << %{  "#{recipe.path}" -> "#{child_recipe.path}";\n}
+        end
+        result << recipe.children._dependency_in_dot
+      end
+
+      result
+    end
+  end
+end