itamae-mitsurin 0.50 → 1.0.0

data/lib/itamae-mitsurin/mitsurin/itamae_with_git_task.rb

@@ -1,159 +0,0 @@
-require 'specinfra'
-require 'specinfra/helper/set'
-require 'itamae-mitsurin/mitsurin/task_base'
-include Specinfra::Helper::Set
-include Rake::DSL if defined? Rake::DSL
-
-module ItamaeMitsurin
-  module Mitsurin
-    class ItamaeWithGitTask
-
-      namespace :itamae do
-        set :backend, :exec
-        branches = Specinfra.backend.run_command('git branch')
-        branch = branches.stdout.split("\n").select {|a| /\*/ === a }
-        branch = branch.join.gsub(/\* (.+)/, '\1')
-        branch << '/**'
-
-        Dir.glob("nodes/#{branch}/*.json").each do |node_file|
-          bname = File.basename(node_file, '.json')
-
-          begin
-            node_h = JSON.parse(File.read(node_file), symbolize_names: true)
-          rescue JSON::ParserError => e
-            puts e.class.to_s + ", " + e.backtrace[0].to_s
-            puts "Node error, nodefile:#{node_file}, reason:#{e.message}"
-          end
-
-          desc "Itamae to #{bname}"
-          task node_h[:environments][:hostname].split(".")[0] do
-            begin
-              recipes = []
-              TaskBase.get_roles(node_file).each do |role|
-                recipes << TaskBase.get_recipes(role)
-              end
-              TaskBase.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 "Node or role error, nodefile:#{node_file}, reason:#{e.message}"
-            else
-              recipes.flatten!
-            end
-
-            # get env attr
-            begin
-              env_set = node_h[:environments][:set]
-              raise "No environments set error" if env_set.nil?
-              env_h = JSON.parse(File.read("environments/#{env_set}.json"), symbolize_names: true)
-            rescue Exception => e
-              puts e.class.to_s + ", " + e.backtrace[0].to_s
-              puts "Node or environment error, nodefile:#{node_file}, reason:#{e.message}"
-            end
-
-            # get recipes attr
-            recipe_attr_file = []
-            recipes.each do |recipe_h|
-              if recipe_h["#{recipe_h.keys.join}"] == "default"
-                recipe_attr_file.insert 0,
-                    Dir.glob("site-cookbooks/**/#{recipe_h.keys.join}/attributes/#{recipe_h["#{recipe_h.keys.join}"]}.json")
-              else
-                recipe_attr_file <<
-                    Dir.glob("site-cookbooks/**/#{recipe_h.keys.join}/attributes/#{recipe_h["#{recipe_h.keys.join}"]}.json")
-              end
-            end
-
-            recipe_attr_file.flatten!
-
-            # recipes attr other=env
-            recipe_env_h_a = []
-            recipe_attr_file.each do |file|
-              recipe_h = JSON.parse(File.read(file), symbolize_names: true)
-              recipe_env_h_a << recipe_h.deep_merge(env_h)
-            end
-
-            # recipe attr other=recipes_env
-            moto = recipe_env_h_a[0]
-            recipe_env_h_a.each {|hash| moto.deep_merge!(hash)}
-            recipe_env_h = moto
-
-            if recipe_env_h.nil?
-              # env attr other=node
-              node_env_h = env_h.deep_merge(node_h)
-              node_env_j = TaskBase.jq node_env_h
-              TaskBase.write_json(bname) {|file| file.puts node_env_j}
-            else
-              # recipe_env attr other=node
-              recipe_env_node_h = recipe_env_h.deep_merge(node_h)
-              recipe_env_node_j = TaskBase.jq recipe_env_node_h
-              TaskBase.write_json(bname) {|file| file.puts recipe_env_node_j}
-            end
-
-            recipes << {'_base' => 'default'}
-            node_property = JSON.parse(File.read("tmp-nodes/#{bname}.json"), symbolize_names: true)
-            node = node_property[:environments][:hostname]
-            ssh_user = node_property[:environments][:ssh_user]
-            ssh_password = node_property[:environments][:ssh_password]
-            sudo_password = node_property[:environments][:sudo_password]
-            ssh_port = node_property[:environments][:ssh_port]
-            ssh_key = node_property[:environments][:ssh_key]
-
-            ENV['TARGET_HOST'] = node
-            ENV['NODE_FILE'] = node_file
-            ENV['SSH_PASSWORD'] = ssh_password
-            ENV['SUDO_PASSWORD'] = sudo_password
-
-            command = "bundle exec itamae ssh"
-            command << " -h #{node}"
-            command << " -u #{ssh_user}"
-            command << " -p #{ssh_port}"
-            command << " -i keys/#{ssh_key}" unless ssh_key.nil?
-            command << " -j tmp-nodes/#{bname}.json"
-            command << " --shell=bash"
-            command << " --ask-password" unless ssh_password.nil?
-            command << " --dry-run" if ENV['dry-run'] == "true"
-            command << " -l debug" if ENV['debug'] == "true"
-            command << " -c logs/config/itamae_with_git_task.config"
-
-            # Pass to read the recipe command
-            command_recipe = []
-            recipes.each do |recipe_h|
-              target_recipe = "site-cookbooks/**/#{recipe_h.keys.join}/recipes/#{recipe_h[recipe_h.keys.join]}.rb"
-              if Dir.glob(target_recipe).empty?
-                raise "Recipe load error, nodefile: #{node_file}, reason: Does not exist " +
-                      recipe_h.keys.join + '::' +recipe_h.values.join
-              end
-              Dir.glob(target_recipe).join("\s").split.each do |target|
-                unless File.exists?(target)
-                  ex_recipe = recipe_h.to_s.gsub('=>', '::').gsub('"', '')
-                  raise "Recipe load error, nodefile:#{node_file}, reason: Does not exist #{ex_recipe}"
-                end
-                command_recipe << " #{target}"
-              end
-            end
-
-            command_recipe.sort_by! {|item| File.dirname(item) }
-            command << command_recipe.join
-
-            puts TaskBase.hl.color(%!Run Itamae to "#{bname}"!, :red)
-            run_list_noti = []
-            command_recipe.each { |c_recipe|
-              unless c_recipe.split("/")[4].split(".")[0] == 'default'
-                run_list_noti << c_recipe.split("/")[2] + "::#{c_recipe.split("/")[4].split(".")[0]}"
-              else
-                run_list_noti << c_recipe.split("/")[2]
-              end
-            }
-
-            puts TaskBase.hl.color(%!Run List to \"#{run_list_noti.uniq.join(", ")}\"!, :green)
-            puts TaskBase.hl.color(%!#{command}!, :white)
-            st = system command
-            exit 1 unless st
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/itamae-mitsurin/mitsurin/task_base.rb

@@ -1,100 +0,0 @@
-require 'json'
-require 'highline'
-require 'tmpdir'
-require 'logger'
-
-module ItamaeMitsurin
-  module Mitsurin
-    module TaskBase
-
-      class << self
-        class ::Hash
-          def deep_merge(other)
-            merger = lambda {|key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2}
-            self.merge(other, &merger)
-          end
-
-          def deep_merge!(other)
-            merger = lambda {|key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2}
-            self.merge!(other, &merger)
-          end
-        end
-
-        def 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 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') => 'default'}
-            end
-          end
-          recipes
-        end
-
-        def 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') => 'default'} unless /role\[(.+)\]/ === recipe
-            end
-          end
-          recipes
-        end
-
-        def jq(*objs)
-          par = nil
-          objs.each {|obj| par = JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)}
-          return par
-        end
-
-        def write_json(filename)
-          File.open "tmp-nodes/#{filename}.json", 'w' do |f|
-            f.flock File::LOCK_EX
-            yield f
-            f.flock File::LOCK_UN
-          end
-        end
-
-        def write_tmp_json(filename)
-          path = Dir.mktmpdir("mitsurin-")
-          open("#{path}/#{filename}.json", "w") do |f|
-            f.flock File::LOCK_EX
-            yield f
-            f.flock File::LOCK_UN
-          end
-          path
-        end
-
-        def hl
-          HighLine.new
-        end
-
-        def handler_logger
-          default = {"handlers"=>[{"type"=>"json", "path"=>"itamae-log.json"}]}
-        end
-
-        def file_logger
-          file_logger = ::Logger.new('logs/itamae.log', 5, 100 * 1024 * 1024).tap do |l|
-            l.formatter = proc do |serverity, datetime, progname, msg|
-              "#{datetime.strftime('%Y %m %d %H:%M:%S %z')} #{serverity} : #{msg}\n"
-            end
-          end
-
-          file_logger
-        end
-      end
-
-    end
-  end
-end

data/test/test_itamae-mitsurin.rb

@@ -1,18 +0,0 @@
-require 'test/unit'
-require "itamae-mitsurin/runner"
-require "itamae-mitsurin/cli"
-require "itamae-mitsurin/recipe"
-require "itamae-mitsurin/resource"
-require "itamae-mitsurin/handler"
-require "itamae-mitsurin/handler_proxy"
-require "itamae-mitsurin/recipe_children"
-require "itamae-mitsurin/logger"
-require "itamae-mitsurin/node"
-require "itamae-mitsurin/backend"
-require "itamae-mitsurin/notification"
-require "itamae-mitsurin/definition"
-require "itamae-mitsurin/ext"
-
-module TestItamaeMitsurin
-  # Your code goes here...
-end

data/test/test_itamae-mitsurin/ext/test_specinfra.rb

@@ -1,39 +0,0 @@
-# TODO: Send patches to Specinfra
-
-module Specinfra
-  module Backend
-    class Base
-      def receive_file(from, to = nil)
-        raise NotImplementedError
-      end
-    end
-
-    class Exec < Base
-      def receive_file(from, to = nil)
-        if to
-          FileUtils.cp(from, to)
-        else
-          ::File.read(from)
-        end
-      end
-    end
-
-    class Ssh < Exec
-      def receive_file(from, to = nil)
-        scp_download!(from, to)
-      end
-
-      private
-
-      def scp_download!(from, to, opt={})
-        if get_config(:scp).nil?
-          set_config(:scp, create_scp)
-        end
-
-        scp = get_config(:scp)
-        scp.download!(from, to, opt)
-      end
-    end
-  end
-end
-

data/test/test_itamae-mitsurin/handler/test_base.rb

@@ -1,40 +0,0 @@
-require 'socket'
-
-module ItamaeMitsurin
-  module Handler
-    class Base
-      attr_reader :recipes, :resources, :actions
-
-      def initialize(options)
-        @options = options
-
-        @recipes = []
-        @resources = []
-        @actions = []
-      end
-
-      def event(type, payload = {})
-        case type
-        when :recipe_started
-          @recipes << payload
-        when :recipe_completed, :recipe_failed
-          @recipes.pop
-        when :resource_started
-          @resources << payload
-        when :resource_completed, :resource_failed
-          @resources.pop
-        when :action_started
-          @actions << payload
-        when :action_completed, :action_failed
-          @actions.pop
-        end
-      end
-
-      private
-
-      def hostname
-        @hostname ||= @options['hostname'] || Socket.gethostname
-      end
-    end
-  end
-end

data/test/test_itamae-mitsurin/handler/test_debug.rb

@@ -1,10 +0,0 @@
-module ItamaeMitsurin
-  module Handler
-    class Debug < Base
-      def event(type, payload = {})
-        super
-        ItamaeMitsurin.logger.info("EVENT:#{type} #{payload}")
-      end
-    end
-  end
-end

data/test/test_itamae-mitsurin/handler/test_fluentd.rb

@@ -1,44 +0,0 @@
-module ItamaeMitsurin
-  module Handler
-    class Fluentd < Base
-      attr_accessor :fluent_logger # for test
-
-      def initialize(*)
-        super
-        load_fluent_logger
-      end
-
-      def event(type, payload = {})
-        super
-
-        unless @fluent_logger.post(type, payload.merge(hostname: hostname))
-          ItamaeMitsurin.logger.warn "Sending logs to Fluentd failed: #{@fluent_logger.last_error}"
-        end
-      end
-
-      private
-
-      def load_fluent_logger
-        begin
-          require 'fluent-logger'
-        rescue LoadError
-          raise "Loading fluent-logger gem failed. Please install 'fluent-logger' gem to use fluentd handler."
-        end
-
-        @fluent_logger = Fluent::Logger::FluentLogger.new(tag_prefix, host: fluentd_host, port: fluentd_port)
-      end
-
-      def tag_prefix
-        @options['tag_prefix'] || 'itamae_server'
-      end
-
-      def fluentd_host
-        @options['host'] || 'localhost'
-      end
-
-      def fluentd_port
-        (@options['port'] || 24224).to_i
-      end
-    end
-  end
-end

data/test/test_itamae-mitsurin/handler/test_json.rb

@@ -1,22 +0,0 @@
-module ItamaeMitsurin
-  module Handler
-    class Json < Base
-      def initialize(*)
-        super
-        require 'time'
-        open_file
-      end
-
-      def event(type, payload = {})
-        super
-        @f.puts({'time' => Time.now.iso8601, 'event' => type, 'payload' => payload}.to_json)
-      end
-
-      private
-
-      def open_file
-        @f = open(@options.fetch('path'), 'a')
-      end
-    end
-  end
-end

data/test/test_itamae-mitsurin/mitsurin/creators/templates/project/.rspec

@@ -1,2 +0,0 @@
---color
--fd