knife-hitori 0.0.1

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/
+vendor/
+.chef/
+
+chef-solo/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in knife-hitori.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ken Morishita
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/knife-hitori.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef/knife/hitori/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'knife-hitori'
+  spec.version       = Chef::Knife::Hitori::VERSION
+  spec.authors       = ['Ken Morishita']
+  spec.email         = %w(mokemokechicken@gmail.com)
+  spec.description   = %q{knife subcommand}
+  spec.summary       = %q{knife subcommand}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_dependency 'chef', '~> 11.4'
+  spec.add_dependency 'knife-ec2', '~> 0.6'
+  spec.add_dependency 'erubis', '~> 2.7'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/chef/knife/hitori/version.rb

@@ -0,0 +1,7 @@
+class Chef
+  class Knife
+    class Hitori
+      VERSION = '0.0.1'
+    end
+  end
+end

data/lib/chef/knife/hitori_base.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+require 'chef/knife'
+require 'knife-hitori'
+
+class Chef
+  class Knife
+    module HitoriBase
+    end
+  end
+end

data/lib/chef/knife/hitori_config.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require 'chef/knife/hitori_base'
+require 'knife-hitori/interactive_configure'
+
+class Chef
+  class Knife
+    class HitoriConfig < Knife
+
+      banner 'knife hitori config (options)'
+
+      include HitoriBase
+      include KnifeHitori::InteractiveConfigure
+      CHEF_DIR = '.chef'
+      KNIFE_FILE = 'knife.rb'
+      EC2_FILE = 'ec2.rb'
+
+      option :base_dir,
+             :short => '-b COOKBOOK_ROOT_DIR',
+             :long => '--base COOKBOOK_ROOT_DIR',
+             :description => 'Chef ROOT Dir of cookbooks, data_bags...',
+             :default => Dir::getwd
+
+      deps do
+        require 'erubis'
+      end
+
+      def run
+        create_knife_ruby
+        conf = ask_ec2_config_all(Chef::Config.knife)
+        conf[:template_file] = KnifeHitori::resource('centos_bootstrap.erb')
+        conf[:ssh_port] = 22
+        create_knife_ec2_ruby(conf)
+      end
+
+      def base_dir
+        config[:base_dir]
+      end
+
+      def chef_dir
+        "#{base_dir}/#{CHEF_DIR}"
+      end
+
+      def create_knife_ruby
+        knife_ruby = "#{chef_dir}/#{KNIFE_FILE}"
+        FileUtils.makedirs(chef_dir) unless ::Dir.exists?(chef_dir)
+        if ::File.exists?(knife_ruby)
+          yes_no = input_arg("overwrite knife.rb (#{knife_ruby}) [y/n] ?", 'N') {|x| x =~ /^[yn]$/i}
+          if yes_no.downcase != 'y'
+            ui.info ui.color('cancel overwrite knife.rb', :yellow)
+            return
+          end
+        end
+
+        template = KnifeHitori::resource('knife.erb')
+        erubis = Erubis::Eruby.new(::File.read(template))
+        ::File.write(knife_ruby, erubis.result({}))
+        ui.info ui.color("write knife.rb in #{knife_ruby}", :green)
+      end
+
+      def create_knife_ec2_ruby(conf)
+        knife_ec2_ruby = "#{chef_dir}/#{EC2_FILE}"
+        template = KnifeHitori::resource('knife_ec2.erb')
+        erubis = Erubis::Eruby.new(::File.read(template))
+        ::File.write(knife_ec2_ruby, erubis.result(config: conf))
+        ui.info ui.color("save settings in #{knife_ec2_ruby}", :green)
+      end
+    end
+  end
+end

data/lib/chef/knife/hitori_cook.rb

@@ -0,0 +1,291 @@
+# coding: utf-8
+
+require 'chef/knife/hitori_base'
+require 'set'
+
+class Chef
+  class Knife
+    class HitoriCook < Knife
+
+      banner 'knife hitori cook (options)'
+
+      include HitoriBase
+
+      deps do
+        require 'net/ssh'
+        require 'net/scp'
+        require 'fog'
+      end
+
+      option :local,
+             :long => '--local',
+             :description => 'run chef-solo locally'
+
+      option :roles,
+             :short => '-R ROLE1[,ROLE2]',
+             :long  => '--roles ROLE1[,ROLE2]',
+             :description => 'override run_list by roles'
+
+      option :recipes,
+             :long => '--recipes RECIPE1[,RECIPE2]',
+             :description => 'override run_list by recipes'
+
+      option :install_chef,
+             :long => '--install-chef',
+             :description => 'Install chef before run cookbook. This process usually have done by hitori-prepare.'
+
+      #########
+      option :tag,
+             :short => '-t TAG_KEY=TAG_VALUE',
+             :long  => '--tag TAG_KEY=TAG_VALUE',
+             :description => 'specify servers by EC2 Tag'
+
+      option :groups,
+             :short => '-g GROUP1[,GROUP2]',
+             :long  => '--groups GROUP1[,GROUP2]',
+             :description => 'specify servers by Security Group'
+
+      option :name,
+             :short => '-n NAME',
+             :long  => '--name NAME',
+             :description => 'specify a server by Instance Name (Name Tag)'
+
+      option :public_ip_address,
+             :long  => '--ip IP_ADDRESS',
+             :description => 'specify a server by Public IP Address'
+
+      def run
+        if config[:local]
+          run_local
+        else
+          run_remote
+        end
+      end
+
+      def run_local
+        Chef::Config[:environment] = nil
+        update_environment(config[:environment]) if config[:environment]
+        Chef::Config[:solo] = true
+        @chef_solo = Chef::Client.new(json_attrs)
+        @chef_solo.run
+      end
+
+      def update_environment(env)
+        Chef::Config[:solo_environment] = env
+        %w(data_bag_path settings_path encrypted_data_bag_secret).each do |name|
+          name = name.to_sym
+          tpl_name = "#{name}_tpl".to_sym
+          if Chef::Config[tpl_name]
+            Chef::Config[name] = sprintf(Chef::Config[tpl_name], env)
+          end
+        end
+      end
+
+      def json_attrs
+        attrs = load_settings || {}
+        # Chef::Mixin::DeepMerge.merge(normal_attrs,normal_attrs_to_merge)
+
+        # Update run_list
+        run_list = new_run_list
+        unless run_list.empty?
+          attrs['run_list'] = run_list
+        end
+        #
+        attrs
+      end
+
+      def load_settings
+        path = Chef::Config[:settings_path]
+        if ::File.exists?(path)
+          return JSON.parse(::File.read(path))
+        end
+        ui.warn "#{path} is not found!!" if path
+        {}
+      end
+
+      def new_run_list
+        run_list = []
+        run_list += config[:roles].split(/,/).map{|r| "role[#{r.strip}]"} if config[:roles]
+        run_list += config[:recipes].split(/,/).map{|r| "recipe[#{r.strip}]"} if config[:recipes]
+        run_list
+      end
+
+
+      #########################################################
+      ## 盛大なコピペ
+      ########################################################
+      def run_remote
+        servers = find_ec2_servers
+        unless servers && !servers.empty?
+          ui.warn ui.color('no server found', :red)
+          return
+        end
+
+        run_list = new_run_list
+        threads = []
+        servers.each_with_index do |server, idx|
+          threads << Thread.new {
+            RunRemoteCook.new(Chef::Config, config, server, :idx => idx, :ui => ui, :run_list => run_list).run
+          }
+        end
+        threads.each do |t|
+          t.join
+        end
+      end
+
+      def find_ec2_servers
+        server = nil
+        3.times do
+          server = fetch_server_info
+          break if server && !server.empty?
+          print '.'
+          sleep 5
+        end
+        puts
+        server
+      end
+
+      def fetch_server_info
+        servers = server_info_list
+
+        if config[:tag]
+          tag_key, tag_value = config[:tag].to_s.split(/=/, 2)
+          servers.select {|x| x.tags[tag_key] == tag_value.to_s}
+        elsif config[:groups]
+          g = Set.new(config[:groups].split(/,/))
+          servers.select {|x| (Set.new(x.groups) & g).size > 0}
+        elsif config[:name]
+          servers.select {|x| x.tags['Name'] == config[:name]}
+        elsif config[:public_ip_address]
+          servers.select {|x| x.public_ip_address == config[:public_ip_address]}
+        end
+      end
+
+      def server_info_list
+        connection = Fog::Compute.new(
+            :provider => 'AWS',
+            :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
+            :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
+            :region => Chef::Config[:knife][:region]
+        )
+        connection.servers.all.to_a
+      end
+    end
+
+    #############################################
+    class RunRemoteCook
+      attr_reader :config, :run_config, :server, :opts, :ui, :knife
+      def initialize(chef_config, run_config, server, opts)
+        @config = chef_config
+        @run_config = run_config
+        @server = server
+        @opts = opts
+        @ui = opts[:ui]
+        @knife = config.knife
+      end
+
+      def run
+        # Install Chef if needed
+        install_chef if run_config[:install_chef]
+
+        # Remove Old Cookbooks
+        console_log "Remove Old Chef Cookbooks in #{server.public_ip_address}\n"
+        mkdir_cmd = <<-EOS
+          [ -e #{knife[:remote_chef_dir]} ] && sudo rm -rf #{knife[:remote_chef_dir]}
+          sudo mkdir -p #{knife[:remote_chef_dir]}
+          sudo chmod 777 #{knife[:remote_chef_dir]}
+        EOS
+        exec_remote(mkdir_cmd)
+        # Upload Cookbooks
+        console_log "Uploading Chef Cookbooks to #{server.public_ip_address}\n"
+        remote_dir = "#{knife[:remote_chef_dir]}/#{File.basename(config[:chef_solo_base_dir])}"
+        chef_solo_filename = 'do_cook.sh'
+        files_info = []
+        files_info << {src: config[:chef_solo_base_dir], dest: knife[:remote_chef_dir], opts: {:recursive => true, :verbose => true}}
+        files_info << {src: KnifeHitori::resource(chef_solo_filename), dest: remote_dir, opts: {:verbose => true}}
+        upload_files(files_info)
+        console_log "Upload is done #{server.public_ip_address}\n"
+        # run chef-solo
+        script = <<-EOS
+          cd #{remote_dir}
+          tr -d '\\r' < #{chef_solo_filename} > .a
+          mv .a #{chef_solo_filename}
+          #{make_run_list_cmd}
+          sudo CHEF_ENV=#{config[:solo_environment]} sh #{chef_solo_filename}
+        EOS
+        exec_remote(script)
+      end
+
+      def install_chef
+        Chef::Log.debug 'install_chef'
+        console_log "Install Chef in #{server.public_ip_address}\n"
+        remote_filename = '/tmp/.install_chef_script'
+        upload_files([{src: knife[:template_file], dest: remote_filename, opts: {:verbose => true}}])
+        exec_remote("sudo sh #{remote_filename}; rm #{remote_filename}")
+      end
+
+      def make_run_list_cmd
+        script = ''
+        if opts[:run_list] && !opts[:run_list].empty?
+          script = <<-EOS
+            [ -d run_list/#{config[:solo_environment]} ] || mkdir -p run_list/#{config[:solo_environment]}
+            echo '#{opts[:run_list].join(',')}' > run_list/#{config[:solo_environment]}/`hostname`
+          EOS
+        end
+        script
+      end
+
+      #######################
+      def bg_color(text)
+        #Background colors
+        #40	Black
+        #41	Red
+        #42	Green
+        #43	Yellow
+        #44	Blue
+        #45	Magenta
+        #46	Cyan
+        #47	White
+        c = 47 - ((opts[:idx].to_i + 3) % 7)
+        "\e[#{c}m#{text}\e[0m"
+      end
+
+      def upload_files(files_info)
+        Net::SCP.start(server.public_ip_address, knife[:ssh_user], :keys => [knife[:identity_file]], :compression => true) do |scp|
+          channels = []
+          files_info.each do |info|
+            channels << scp.upload(info[:src], info[:dest], info[:opts])
+          end
+          channels.each do |ch|
+            ch.wait
+          end
+        end
+      end
+
+      def exec_remote(command)
+        Net::SSH.start(server.public_ip_address, knife[:ssh_user], :keys => [knife[:identity_file]]) do |ssh|
+          ssh.open_channel do |ch|
+            ch.request_pty do |pty, success|
+              raise 'Could not obtain pty' unless success
+            end
+            ch.exec(command) do |c, success|
+              abort 'could not execute command' unless success
+              ch.on_data do |c, data|
+                console_log data
+              end
+
+              ch.on_extended_data do |c, type, data|
+                console_log data
+              end
+            end
+          end
+        end
+      end
+
+      def console_log(msg)
+        print bg_color(msg)
+      end
+    end
+
+  end
+end

data/lib/chef/knife/hitori_hello.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'chef/knife/hitori_base'
+
+class Chef
+  class Knife
+    class HitoriHello < Knife
+      include HitoriBase
+      banner 'knife hitori hello (options)'
+
+      option :name,
+             :short => '-n name',
+             :long => '--name name',
+             :description => 'specify you name'
+
+      def run
+        puts 'Hello Knife::Hitori.'
+        p Chef::Config
+        puts '-' * 50
+        p config
+      end
+    end
+  end
+end
+

data/lib/chef/knife/hitori_prepare.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+require 'chef/knife/hitori_base'
+require 'knife-hitori/interactive_configure'
+
+class Chef
+  class Knife
+    class HitoriPrepare < Knife
+
+      banner 'knife hitori prepare (options)'
+
+      include HitoriBase
+      include KnifeHitori::InteractiveConfigure
+
+      attr_reader :server
+
+      deps do
+        require 'chef/knife/ec2_server_create'
+      end
+
+      def run
+        conf = ask_ec2_config_all(Chef::Config.knife, true)
+        ec2 = setup_knife_ec2(conf)
+        ec2.run
+        @server = ec2.server
+      end
+
+      def setup_knife_ec2(conf)
+        Chef::Knife::Ec2ServerCreate.load_deps
+        args = []
+        args << '--groups=' + conf[:security_groups]
+        args << '--availability-zone=' + conf[:availability_zone]
+        args << '--image=' + conf[:image]
+        args << '--flavor=' + conf[:flavor]
+
+        args << '--ssh-user=' + conf[:ssh_user]
+        args << '--ssh-port=' + conf[:ssh_port].to_s
+        args << '--identity-file=' + conf[:identity_file]
+        args << '--ssh-key=' + conf[:aws_ssh_key_id]
+        args << '--region=' + conf[:region]
+        args << '--template-file=' + conf[:template_file]
+        ui.info args.join(' ')
+        Chef::Knife::Ec2ServerCreate.new(args)
+      end
+    end
+  end
+end

data/lib/knife-hitori/interactive_configure.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+module KnifeHitori
+  module InteractiveConfigure
+    def ask_ec2_config_all(knife, runtime=false)
+      config = {}
+      config[:aws_access_key_id] = input_arg('aws_access_key_id', knife[:aws_access_key_id], ENV['AWS_ACCESS_KEY_ID']) unless runtime
+      config[:aws_secret_access_key] = input_arg('aws_secret_access_key', knife[:aws_secret_access_key], ENV['AWS_SECRET_ACCESS_KEY']) unless runtime
+      config[:image] = input_arg('ami image', knife[:image], ENV['EC2_AMI_IMAGE'])
+      config[:flavor] = input_arg('flavor', knife[:flavor], ENV['EC2_FLAVOR'], 'm1.small')
+      config[:security_groups] = input_arg('Security Group', knife[:security_groups], ENV['EC2_SECURITY_GROUP'], 'default')
+      config[:ssh_user] = input_arg('ssh_user', knife[:ssh_user], ENV['EC2_SSH_USER'], 'ec2-user')
+      config[:identity_file] = k = input_arg('identity_file(*.pem)', knife[:identity_file], ENV['EC2_PRIVATE_KEY'])
+      config[:aws_ssh_key_id] = input_arg('ssh_key_name', knife[:aws_ssh_key_id], ENV['EC2_SSH_KEY'], File.basename(k || '').sub(/\.pem$/, ''))
+      config[:availability_zone] = input_arg('availability_zone', knife[:availability_zone], ENV['EC2_AVAILABILITY_ZONE'])
+      config[:region] = input_arg('region', knife[:region], config[:availability_zone][0...-1], ENV['EC2_REGION'])
+      config[:identity_file] = File.absolute_path(config[:identity_file]) if config[:identity_file]
+      config[:template_file] = knife[:template_file] if runtime
+      config[:ssh_port] = knife[:ssh_port] if runtime
+      config
+    end
+
+    def input_arg(message, *defaults)
+      input = nil
+      default = defaults.select { |x| !x.to_s.empty? }.first
+      while true
+        print "#{message} [#{default}] ? "
+        input = STDIN.gets.strip
+        input = input.empty? ? default : input
+        break if not block_given? or yield(input)
+      end
+      input
+    end
+  end
+end

data/lib/knife-hitori/resources/centos_bootstrap.erb

@@ -0,0 +1,47 @@
+bash<<'END_OF_BASH'
+
+yum -y update
+yum -y install gcc kernel-devel zlib-devel openssl-devel readline-devel curl-devel libyaml-devel sqlite-devel git make libxml2-devel libxslt-devel wget
+
+RUBY_VERSION="1.9.3-p429"
+
+HOME=/root
+RBENV_ROOT=${HOME}/.rbenv
+cd $HOME
+git clone git://github.com/sstephenson/rbenv.git $RBENV_ROOT
+
+
+RBENV_SH=${RBENV_ROOT}/rbenv.sh
+cat > $RBENV_SH <<EOM
+export PATH="${RBENV_ROOT}/bin:\$PATH"
+export RBENV_DIR=$RBENV_ROOT
+export RBENV_ROOT=$RBENV_ROOT
+eval "\$(rbenv init -)"
+EOM
+
+
+chmod 755 $RBENV_SH
+. $RBENV_SH
+
+
+# install ruby-build
+mkdir -p ${RBENV_DIR}/plugins
+git clone git://github.com/sstephenson/ruby-build.git ${RBENV_DIR}/plugins/ruby-build
+
+# install ruby
+rbenv rehash
+sleep 5
+
+rbenv install $RUBY_VERSION
+rbenv rehash
+rbenv global $RUBY_VERSION
+
+gem update --no-rdoc --no-ri
+gem install bundler --no-rdoc --no-ri --verbose
+gem install ohai --no-rdoc --no-ri --verbose
+gem install chef --no-rdoc --no-ri --verbose
+
+eval "$(rbenv init -)"
+
+END_OF_BASH
+

data/lib/knife-hitori/resources/do_cook.sh

@@ -0,0 +1,37 @@
+#!/bin/sh
+# run_chef_solo.sh
+
+set -e -a
+
+THIS_DIR=$(cd $(dirname $0); pwd)
+
+if [ -z "$CHEF_ENV" -a -e ${THIS_DIR}/.chef_env ]; then
+    CHEF_ENV=$(cat ${THIS_DIR}/.chef_env)
+else
+    CHEF_ENV=${CHEF_ENV:-dev}
+fi
+
+cd $THIS_DIR
+
+CHEF_SOLO_DIR=$THIS_DIR
+SOLO=${CHEF_SOLO_DIR}/.chef/knife.rb
+RBENV_FILE=${RBENV_FILE:-/root/.rbenv/rbenv.sh}
+RUNLIST_FILE=${CHEF_SOLO_DIR}/run_list/${CHEF_ENV}/`hostname`
+SERVER_JSON=${CHEF_SOLO_DIR}/environments/${CHEF_ENV}/settings.json
+
+OPTIONS=""
+if [ "$#" -gt 0 ]; then
+    OPTIONS="$@"
+elif [ -e $RUNLIST_FILE ]; then
+    OPTIONS="-o $(cat $RUNLIST_FILE)"
+elif [ -n "$CHEF_ROLE" ]; then
+    OPTIONS="-o role[${CHEF_ROLE}]"
+fi
+
+# enable rbenv and chef
+if [ -e $RBENV_FILE ]; then
+    . $RBENV_FILE
+fi
+
+echo chef-solo -c $SOLO -j $SERVER_JSON $OPTIONS
+chef-solo -c $SOLO -j $SERVER_JSON $OPTIONS