itamae-spec 0.0.2

data/lib/itamae-spec/resource.rb

@@ -0,0 +1,2 @@
+require 'itamae-spec/resource/http_request'
+require 'itamae-spec/resource/s3_file'

data/lib/itamae-spec/resource/http_request.rb

@@ -0,0 +1,71 @@
+
+module Itamae
+  module Resource
+    class HttpRequest
+      def pre_action
+        attributes.content = fetch_content
+        current.exist = run_specinfra(:check_file_is_file, attributes.path)
+        attributes.exist = true
+
+        send_tempfile
+        compare_file
+      end
+
+      def show_differences
+        current.mode    = current.mode.rjust(4, '0') if current.mode
+        attributes.mode = attributes.mode.rjust(4, '0') if attributes.mode
+
+        @current_attributes.each_pair do |key, current_value|
+          value = @attributes[key]
+          if current_value.nil? && value.nil?
+            # ignore
+          elsif current_value.nil? && !value.nil?
+            Itamae.logger.color :green do
+              Itamae.logger.info "#{resource_type}[#{resource_name}] #{key} will be '#{value}'"
+            end
+          elsif current_value == value || value.nil?
+            Itamae.logger.debug "#{resource_type}[#{resource_name}] #{key} will not change (current value is '#{current_value}')"
+          else
+            Itamae.logger.color :green do
+              Itamae.logger.info "#{resource_type}[#{resource_name}] #{key} will change from '#{current_value}' to '#{value}'"
+            end
+          end
+        end
+
+        show_content_diff
+      end
+
+      def fetch_content
+        uri = URI.parse(attributes.url)
+        response = nil
+        redirects_followed = 0
+
+        loop do
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true if uri.scheme == "https"
+
+          case @current_action
+          when :delete, :get, :options
+            response = http.method(@current_action).call(uri.request_uri, attributes.headers)
+          when :post, :put
+            response = http.method(@current_action).call(uri.request_uri, attributes.message, attributes.headers)
+          end
+
+          if response.kind_of?(Net::HTTPRedirection)
+            if redirects_followed < attributes.redirect_limit
+              uri = URI.parse(response["location"])
+              redirects_followed += 1
+              ItamaeMitsurin.logger.debug "Following redirect #{redirects_followed}/#{attributes.redirect_limit}"
+            else
+              raise RedirectLimitExceeded
+            end
+          else
+            break
+          end
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/itamae-spec/resource/s3_file.rb

@@ -0,0 +1,31 @@
+require 'aws-sdk'
+
+module Itamae
+  module Resource
+    class S3File < File
+      define_attribute :object_key, type: String, default_name: true
+      define_attribute :region, type: String, required: true
+      define_attribute :bucket, type: String, required: true
+      define_attribute :profile, type: String, default: 'default'
+
+      private
+
+      def pre_action
+        credentials = Aws::SharedCredentials.new(profile_name: attributes.profile)
+        @s3 = Aws::S3::Client.new(region: attributes.region, credentials: credentials)
+        attributes.content = fetch_content
+
+        super
+      end
+
+      def fetch_content
+        case @current_action
+        when :create, :delete, :edit
+          resp = @s3.get_object(bucket: attributes.bucket, key: attributes.object_key)
+        end
+
+        resp.body.read
+      end
+    end
+  end
+end

data/lib/itamae-spec/task/base.rb

@@ -0,0 +1,90 @@
+require 'multi_json'
+require 'itamae'
+
+module ItamaeSpec
+  module Task
+    module Base
+      RoleLoadError = Class.new(StandardError)
+
+      class ::Hash
+        def deep_merge(other_hash, &block)
+          dup.deep_merge!(other_hash, &block)
+        end
+
+        def deep_merge!(other_hash, &block)
+          merge!(other_hash) do |key, this_val, other_val|
+            if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+              this_val.deep_merge(other_val, &block)
+            elsif block_given?
+              yield(key, this_val, other_val)
+            else
+              other_val
+            end
+          end
+        end
+
+        def to_pretty_json
+          MultiJson.dump(self, symbolize_keys: true, pretty: true)
+        end
+      end
+
+      class ::Regexp
+        def match?(m)
+          if self.match(m)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      class << self
+        def get_role_recipes(role)
+          recipes = []
+          JSON.parse(File.read("roles/#{role}.json"))['run_list'].each do |recipe|
+            if /recipe\[(.+)::(.+)\]/.match?(recipe)
+              recipes << { recipe.gsub(/recipe\[(.+)::(.+)\]/, '\1') => recipe.gsub(/recipe\[(.+)::(.+)\]/, '\2') }
+            elsif /recipe\[(.+)\]/.match?(recipe)
+              recipes << { recipe.gsub(/recipe\[(.+)\]/, '\1') => 'default' }
+            end
+          end
+        rescue JSON::ParserError
+          raise RoleLoadError, "JSON Parser Faild. - roles/#{role}.json"
+        rescue Errno::ENOENT
+          raise RoleLoadError, "No such role file or directory - roles/#{role}.json"
+        else
+          recipes
+        end
+
+        def get_node_recipes(node_file)
+          recipes = []
+          JSON.parse(File.read(node_file))['run_list'].each do |recipe|
+            if /recipe\[(.+)::(.+)\]/.match?(recipe)
+              recipes << { recipe.gsub(/recipe\[(.+)::(.+)\]/, '\1') => recipe.gsub(/recipe\[(.+)::(.+)\]/, '\2') }
+            elsif /recipe\[(.+)\]/.match?(recipe)
+              recipes << { recipe.gsub(/recipe\[(.+)\]/, '\1') => 'default' }
+            elsif /role\[(.+)\]/.match?(recipe)
+              recipes << get_role_recipes(recipe.gsub(/role\[(.+)\]/, '\1'))
+            end
+          end
+        rescue JSON::ParserError
+          raise RoleLoadError, "JSON Parser Faild. - #{node_file}"
+        rescue Errno::ENOENT
+          raise RoleLoadError, "No such node file or directory - #{node_fie}"
+        else
+          recipes
+        end
+
+        def write_tmp_nodes(filename)
+          Itamae.logger.info "Output attributes log file to: tmp-nodes/#{filename}.json"
+
+          File.open "tmp-nodes/#{filename}.json", 'w' do |f|
+            f.flock File::LOCK_EX
+            yield f
+            f.flock File::LOCK_UN
+          end
+        end
+      end
+    end
+  end
+end

data/lib/itamae-spec/task/base_task.rb

@@ -0,0 +1,148 @@
+require 'itamae-spec/task/base'
+
+module ItamaeSpec
+  module Task
+    class BaseTask
+      extend Rake::DSL if defined? Rake::DSL
+
+      EnvironmentsSetError = Class.new(StandardError)
+      LoadRecipeError = Class.new(StandardError)
+      LoadAttributeError = Class.new(StandardError)
+
+      def load_node_attributes(node_file)
+        JSON.parse(File.read(node_file), symbolize_names: true)
+      rescue JSON::ParserError
+        raise LoadAttributeError, "JSON Parser Failed. - #{node_file}"
+      end
+
+      def load_run_list(node_file)
+        run_list = []
+        Base.get_node_recipes(node_file).each {|recipe| run_list << recipe }
+        run_list.flatten
+      end
+
+      def load_environments(hash)
+        set = hash[:environments][:set]
+        raise EnvironmentsSetError, 'Environments Set is not specified in nodefile' if set.nil?
+        JSON.parse(File.read("environments/#{set}.json"), symbolize_names: true)
+      rescue JSON::ParserError
+        raise LoadAttributeError, "JSON Parser Failed. - environments/#{set}.json"
+      end
+
+      def load_recipe_attributes(run_list)
+        recipe_files = run_list.map do |recipe|
+          Dir.glob("cookbooks/**/#{recipe.keys.join}/attributes/#{recipe.values.join}.json")
+        end.flatten
+
+        recipe_files.map do |f|
+          begin
+            JSON.parse(File.read(f), symbolize_names: true)
+          rescue JSON::ParserError
+            raise LoadAttributeError, "JSON Parser Failed. - #{f}"
+          end
+        end
+      end
+
+      def merge_attributes(source, other = nil)
+        if source.class == Hash
+          merged = source.deep_merge(other)
+        elsif source.class == Array
+          if source.empty?
+            merged = {}
+          else
+            merged = source[0]
+            source.each {|s| merged.deep_merge!(s) }
+          end
+        end
+
+        merged
+      end
+
+      def create_tmp_nodes(filename, hash)
+        json = hash.to_pretty_json
+        Base.write_tmp_nodes(filename) {|f| f.puts json }
+      end
+
+      def create_itamae_command(node_name, hash)
+        ENV['SUDO_PASSWORD'] if hash[:environments][:sudo_password]
+
+        command = 'bundle exec itamae-spec ssh'
+        command << if hash[:environments][:local_ipv4]
+                     " -h #{hash[:environments][:local_ipv4]}"
+                   else
+                     " -h #{hash[:environments][:hostname]}"
+                   end
+
+        command << " -u #{hash[:environments][:ssh_user]}"
+        command << " -p #{hash[:environments][:ssh_port]}"
+        command << " -i keys/#{hash[:environments][:ssh_key]}" if hash[:environments][:ssh_key]
+        command << " -j tmp-nodes/#{node_name}.json"
+
+        hash[:environments][:shell] = ENV['shell'] if ENV['shell']
+        command << if hash[:environments][:shell]
+                     " --shell=#{hash[:environments][:shell]}"
+                   else
+                     ' --shell=bash'
+                   end
+
+        command << " --password=#{hash[:environments][:ssh_password]}" if hash[:environments][:ssh_password]
+        command << ' --dry-run' if ENV['dry-run'] == 'true'
+        command << ' --log-level=debug' if ENV['debug'] == 'true'
+        command << ' --vagrant' if ENV['vagrant'] == 'true'
+        command
+      end
+
+      def create_spec_command(node_name, hash)
+        ENV['TARGET_HOST'] = if hash[:environments][:local_ipv4].nil?
+                               hash[:environments][:hostname]
+                             else
+                               hash[:environments][:local_ipv4]
+                             end
+
+        ENV['NODE_FILE'] = "tmp-nodes/#{node_name}.json"
+        ENV['SSH_PASSWORD'] = hash[:environments][:ssh_password]
+        ENV['SUDO_PASSWORD'] = hash[:environments][:sudo_password]
+        ENV['SSH_KEY'] = "keys/#{hash[:environments][:ssh_key]}"
+        ENV['SSH_USER'] = hash[:environments][:ssh_user]
+        ENV['SSH_PORT'] = hash[:environments][:ssh_port]
+
+        command = 'bundle exec rspec'
+        # ENV['vagrant'] TODO
+      end
+
+      def list_recipe_filepath(run_list)
+        recipes = []
+        run_list.each do |recipe|
+          target_list = Dir.glob("cookbooks/**/#{recipe.keys.join}/recipes/#{recipe.values.join}.rb")
+
+          raise LoadRecipeError, "#{recipe.to_a.join('::')} cookbook or recipe does not exist." if target_list.empty?
+
+          target_list.each do |target|
+            recipes << " #{target}"
+          end
+        end
+
+        recipes
+      end
+
+      def runner_display(raw_run_list, run_list, command)
+        run_list_str = run_list.map do |recipe|
+          if recipe.values.join == 'default'
+            recipe.keys.join
+          else
+            "#{recipe.keys.join}::#{recipe.values.join}"
+          end
+        end
+
+        Itamae.logger.color(:green) do
+          Itamae.logger.info "Run List is [#{raw_run_list.join(', ')}]"
+          Itamae.logger.info "Run List expands to [#{run_list_str.join(', ')}]"
+        end
+
+        Itamae.logger.color(:white) do
+          Itamae.logger.info command
+        end
+      end
+    end
+  end
+end

data/lib/itamae-spec/task/itamae_task.rb

@@ -0,0 +1,112 @@
+require 'itamae-spec/task/base_task'
+
+module ItamaeSpec
+  module Task
+    class ItamaeTask < BaseTask
+      ChangeTargetError = Class.new(StandardError)
+
+      def list_recipe_filepath(run_list)
+        recipes = []
+        run_list.each do |recipe|
+          target_list = Dir.glob("cookbooks/#{recipe.keys.join}/recipes/#{recipe.values.join}.rb")
+
+          raise LoadRecipeError, "#{recipe.to_a.join('::')} cookbook or recipe does not exist." if target_list.empty?
+
+          target_list.each do |target|
+            recipes << " #{target}"
+          end
+        end
+
+        recipes
+      end
+
+      Itamae.logger.formatter.colored = true
+      task = ItamaeTask.new
+
+      namespace :itamae do
+        all = []
+
+        begin
+          project = { project: ARGV[1] }
+
+          if (ARGV[0] == '-T' || ARGV[0] == '--tasks') && !project[:project].nil?
+            unless Dir.exist?("nodes/#{project[:project]}")
+              raise ChangeTargetError, "'#{project[:project]}' project is not exist."
+            end
+
+            File.open 'Project.json', 'w' do |f|
+              f.flock File::LOCK_EX
+              f.puts project.to_json
+              f.flock File::LOCK_UN
+            end
+
+            Itamae.logger.color(:green) do
+              Itamae.logger.info "Changed target mode '#{project[:project]}'"
+            end
+          end
+
+          resp = JSON.parse(File.read('Project.json'))
+          target = resp['project'] << '/**'
+        rescue Errno::ENOENT
+          Itamae.logger.error 'Please select target. - ex: $ rake -T .'
+        rescue => e
+          Itamae.logger.error e.inspect
+          exit 2
+        end
+
+        Dir.glob("nodes/#{target}/*.json").each do |node_file|
+          begin
+            node_name = File.basename(node_file, '.json')
+            node = task.load_node_attributes(node_file)
+            node_short = node[:environments][:hostname].split('.')[0]
+          rescue => e
+            Itamae.logger.error e.inspect
+            Itamae.logger.info "From node file: #{node_file}"
+            exit 2
+          end
+
+          all << node_short
+          desc 'Itamae to all nodes'
+          task 'all' => all
+
+          desc "Itamae to #{node_name}"
+          task node_short do
+            Itamae.logger.color(:cyan) do
+              Itamae.logger.info "Start itamae_task to #{node[:environments][:hostname]}"
+            end
+
+            begin
+              run_list = task.load_run_list(node_file)
+              environments = task.load_environments(node)
+              recipe_attributes_list = task.load_recipe_attributes(run_list)
+
+              merged_recipe = task.merge_attributes(recipe_attributes_list)
+              merged_environments = task.merge_attributes(merged_recipe, environments)
+              attributes = task.merge_attributes(merged_environments, node)
+              task.create_tmp_nodes(node_name, attributes)
+
+              command = task.create_itamae_command(node_name, attributes)
+              command_recipe = task.list_recipe_filepath(run_list)
+              command << command_recipe.join
+
+              task.runner_display(attributes[:run_list], run_list, command)
+              st = system command
+              if st
+                Itamae.logger.color(:green) do
+                  Itamae.logger.info 'itamae_task is completed.'
+                end
+              else
+                Itamae.logger.error 'itamae_task is failed.'
+                exit 1
+              end
+            rescue => e
+              Itamae.logger.error e.inspect
+              Itamae.logger.info "From node file: #{node_file}"
+              exit 2
+            end
+          end
+        end
+      end
+    end
+  end
+end