itamae-mitsurin 0.4 → 0.7

data/test/test_itamae-mitsurin/test_recipe.rb

@@ -0,0 +1,171 @@
+require 'itamae-mitsurin'
+
+module ItamaeMitsurin
+  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
+        ItamaeMitsurin.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
+      ItamaeMitsurin.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)
+          ItamaeMitsurin.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
+        ItamaeMitsurin.logger.debug "#{@definition.resource_type}[#{@definition.resource_name}]"
+      end
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_recipe_children.rb

@@ -0,0 +1,86 @@
+module ItamaeMitsurin
+  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 = ItamaeMitsurin::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

data/test/test_itamae-mitsurin/test_resource.rb

@@ -0,0 +1,73 @@
+require 'itamae-mitsurin'
+require 'itamae-mitsurin/mitsurin'
+require 'itamae-mitsurin/resource/base'
+require 'itamae-mitsurin/resource/file'
+require 'itamae-mitsurin/resource/package'
+require 'itamae-mitsurin/resource/remote_directory'
+require 'itamae-mitsurin/resource/remote_file'
+require 'itamae-mitsurin/resource/directory'
+require 'itamae-mitsurin/resource/template'
+require 'itamae-mitsurin/resource/http_request'
+require 'itamae-mitsurin/resource/execute'
+require 'itamae-mitsurin/resource/service'
+require 'itamae-mitsurin/resource/link'
+require 'itamae-mitsurin/resource/local_ruby_block'
+require 'itamae-mitsurin/resource/git'
+require 'itamae-mitsurin/resource/user'
+require 'itamae-mitsurin/resource/group'
+require 'itamae-mitsurin/resource/gem_package'
+require 'itamae-mitsurin/resource/aws_ebs_volume'
+
+module ItamaeMitsurin
+  module Resource
+    Error = Class.new(StandardError)
+    AttributeMissingError = Class.new(StandardError)
+    InvalidTypeError = Class.new(StandardError)
+    ParseError = Class.new(StandardError)
+
+    class << self
+      def to_camel_case(str)
+        str.split('_').map {|part| part.capitalize}.join
+      end
+
+      def get_resource_class(method)
+        begin
+          self.const_get(to_camel_case(method.to_s))
+        rescue NameError
+          begin
+            ::ItamaeMitsurin::Plugin::Resource.const_get(to_camel_case(method.to_s))
+          rescue NameError
+            autoload_plugin_resource(method)
+          end
+        end
+      end
+
+      def autoload_plugin_resource(method)
+        begin
+          require "itamae/plugin/resource/#{method}"
+          ::ItamaeMitsurin::Plugin::Resource.const_get(to_camel_case(method.to_s))
+        rescue LoadError, NameError
+          raise Error, "#{method} resource is missing."
+        end
+      end
+
+      def define_resource(name, klass)
+        class_name = to_camel_case(name.to_s)
+        if Resource.const_defined?(class_name)
+          ItamaeMitsurin.logger.warn "Redefine class. (#{class_name})"
+          return
+        end
+
+        Resource.const_set(class_name, klass)
+      end
+
+      def parse_description(desc)
+        if /\A([^\[]+)\[([^\]]+)\]\z/ =~ desc
+          [$1, $2]
+        else
+          raise ParseError, "'#{desc}' doesn't represent a resource."
+        end
+      end
+    end
+  end
+end

data/test/test_itamae-mitsurin/test_runner.rb

@@ -0,0 +1,124 @@
+require 'itamae-mitsurin'
+require 'json'
+require 'yaml'
+
+module ItamaeMitsurin
+  class Runner
+    class << self
+      def run(recipe_files, backend_type, options)
+        ItamaeMitsurin.logger.info "Starting Itamae..."
+
+        backend = Backend.create(backend_type, options)
+        runner = self.new(backend, options)
+        runner.load_recipes(recipe_files)
+        runner.run
+      end
+    end
+
+    attr_reader :backend
+    attr_reader :options
+    attr_reader :node
+    attr_reader :tmpdir
+    attr_reader :children
+    attr_reader :handler
+
+    def initialize(backend, options)
+      @backend = backend
+      @options = options
+
+      prepare_handler
+
+      @node = create_node
+      @tmpdir = "/tmp/itamae_tmp"
+      @children = RecipeChildren.new
+
+      @backend.run_command(["mkdir", "-p", @tmpdir])
+      @backend.run_command(["chmod", "777", @tmpdir])
+    end
+
+    def load_recipes(paths)
+      paths.each do |path|
+        expanded_path = File.expand_path(path)
+        if path.include?('::')
+          gem_path = Recipe.find_recipe_in_gem(path)
+          expanded_path = gem_path if gem_path
+        end
+
+        recipe = Recipe.new(self, expanded_path)
+        children << recipe
+        recipe.load
+      end
+    end
+
+    def run
+      if recipe_graph_file = options[:recipe_graph]
+        save_dependency_graph(recipe_graph_file)
+      end
+
+      children.run
+      @backend.finalize
+
+      if profile = options[:profile]
+        save_profile(profile)
+      end
+    end
+
+    def dry_run?
+      @options[:dry_run]
+    end
+
+    def save_dependency_graph(path)
+      ItamaeMitsurin.logger.info "Writing recipe dependency graph to #{path}..."
+      open(path, 'w') do |f|
+        f.write(children.dependency_in_dot)
+      end
+    end
+
+    def save_profile(path)
+      open(path, 'w', 0600) do |f|
+        f.write(@backend.executed_commands.to_json)
+      end
+    end
+
+    private
+    def create_node
+      hash = {}
+
+      if @options[:ohai]
+        unless @backend.run_command("which ohai", error: false).exit_status == 0
+          # install Ohai
+          ItamaeMitsurin.logger.info "Installing Chef package... (to use Ohai)"
+          @backend.run_command("curl -L https://www.opscode.com/chef/install.sh | bash")
+        end
+
+        ItamaeMitsurin.logger.info "Loading node data via ohai..."
+        hash.merge!(JSON.parse(@backend.run_command("ohai").stdout))
+      end
+
+      if @options[:node_json]
+        path = File.expand_path(@options[:node_json])
+        ItamaeMitsurin.logger.info "Loading node data from #{path}..."
+        hash.merge!(JSON.load(open(path)))
+      end
+
+      if @options[:node_yaml]
+        path = File.expand_path(@options[:node_yaml])
+        ItamaeMitsurin.logger.info "Loading node data from #{path}..."
+        hash.merge!(YAML.load(open(path)) || {})
+      end
+
+      Node.new(hash, @backend)
+    end
+
+    def prepare_handler
+      @handler = HandlerProxy.new
+      (@options[:handlers] || []).each do |handler|
+        type = handler.delete('type')
+        unless type
+          raise "#{type} field is not set"
+        end
+        @handler.register_instance(Handler.from_type(type).new(handler))
+      end
+    end
+  end
+end