knife-stackbuilder 0.5.2

data/lib/stackbuilder/chef/stack_node_manager.rb

@@ -0,0 +1,251 @@
+# Copyright (c) 2014 Mevan Samaratunga
+
+include StackBuilder::Common::Helpers
+
+module StackBuilder::Chef
+
+    class NodeManager < StackBuilder::Stack::NodeManager
+
+        include ERB::Util
+
+        attr_accessor :name
+
+        attr_accessor :run_list
+        attr_accessor :run_on_event
+
+        def initialize(id, node_config, repo_path, environment)
+
+            @logger = StackBuilder::Common::Config.logger
+
+            @id = id
+            @name = node_config['node']
+            @node_id = @name + '-' + @id
+
+            @run_list = node_config.has_key?('run_list') ? node_config['run_list'].join(',') : nil
+            @run_on_event = node_config['run_on_event']
+
+            @knife_config = node_config['knife']
+            if @knife_config
+
+                raise ArgumentError, 'An ssh user needs to be provided for bootstrap and knife ssh.' \
+                    unless @knife_config['options'].has_key?('ssh_user')
+
+                raise ArgumentError, 'An ssh key file or password must be provided for knife to be able ssh to a node.' \
+                    unless @knife_config['options'].has_key?('identity_file') ||
+                       @knife_config['options'].has_key?('ssh_password')
+
+                @ssh_user = @knife_config['options']['ssh_user']
+                @ssh_password = @knife_config['options']['ssh_password']
+                @identity_file = @knife_config['options']['identity_file']
+
+                @env_key_file = "#{repo_path}/secrets/#{environment}"
+                @env_key_file = nil unless File.exist?(@env_key_file)
+            end
+        end
+
+        def get_name
+            @name
+        end
+
+        def get_scale
+            get_stack_node_resources
+        end
+
+        def node_attributes
+            get_stack_node_resources
+            @nodes.collect { |n| n.attributes }
+        end
+
+        def create(index)
+
+            name = "#{@node_id}-#{index}"
+            self.create_vm(name, @knife_config)
+
+            knife_cmd = KnifeAttribute::Node::NodeAttributeSet.new
+            knife_cmd.name_args = [ name, 'stack_id', @id ]
+            knife_cmd.config[:type] = 'override'
+            run_knife(knife_cmd)
+
+            knife_cmd = KnifeAttribute::Node::NodeAttributeSet.new
+            knife_cmd.name_args = [ name, 'stack_node', @name ]
+            knife_cmd.config[:type] = 'override'
+            run_knife(knife_cmd)
+
+            unless @env_key_file.nil?
+                env_key = IO.read(@env_key_file)
+                knife_ssh(name, "echo '#{env_key}' > /etc/chef/encrypted_data_bag_secret")
+            end
+
+        rescue Exception => msg
+            puts("\nError creating node #{name} using knife config: #{msg}\n#{@knife_config.to_yaml}\n")
+            @logger.info(msg.backtrace.join("\n\t")) if @logger.debug
+
+            raise msg
+        end
+
+        def create_vm(name, knife_config)
+            raise NotImplemented, 'HostNodeManager.create_vm'
+        end
+
+        def process(index, events, attributes, target = nil)
+
+            if target.nil?
+                self.process_vm(index, events, attributes)
+            else
+                target.process_vm(index, events, attributes, self)
+            end
+        end
+
+        def process_vm(index, events, attributes, node_manager = nil)
+
+            name = "#{@node_id}-#{index}"
+
+            if node_manager.nil?
+                run_list = @run_list
+                run_on_event = @run_on_event
+            else
+                run_list = node_manager.run_list
+                run_on_event = node_manager.run_on_event
+            end
+
+            set_attributes(name, attributes)
+
+            if (events.include?('configure') || events.include?('update')) && !run_list.nil?
+
+                log_level = (
+                    @logger.debug? ? 'debug' :
+                    @logger.info? ? 'info' :
+                    @logger.warn? ? 'warn' :
+                    @logger.error? ? 'error' :
+                    @logger.fatal? ? 'fatal' : 'error' )
+
+                knife_cmd = Chef::Knife::NodeRunListSet.new
+                knife_cmd.name_args = [ name, run_list ]
+                run_knife(knife_cmd)
+
+                knife_ssh( name,
+                    "TMPFILE=`mktemp`\n" +
+                    "echo '#{attributes.to_json}' > $TMPFILE\n" +
+                    "chef-client -l #{log_level} -j $TMPFILE\n" +
+                    "result=$?\n" +
+                    "rm -f $TMPFILE\n" +
+                    "exit $result" )
+            end
+
+            run_on_event.each_pair { |event, cmd|
+                knife_ssh(name, ERB.new(cmd, nil, '-<>').result(binding)) if events.include?(event) } \
+                unless run_on_event.nil?
+
+        rescue Exception => msg
+
+            puts( "\nError processing node #{name}: #{msg} " +
+                "\nEvents => #{events.collect { |e| e } .join(", ")}" +
+                "\nknife config =>\n#{@knife_config.to_yaml}" +
+                "\nrun list =>\n#{run_list}" +
+                "\nevent scripts =>\n#{run_on_event.to_yaml}\n" )
+
+            @logger.info(msg.backtrace.join("\n\t")) if @logger.debug
+
+            raise msg
+        end
+
+        def delete(index)
+
+            name = "#{@node_id}-#{index}"
+            self.delete_vm(name, @knife_config)
+
+            knife_cmd = Chef::Knife::NodeDelete.new
+            knife_cmd.name_args = [ name ]
+            knife_cmd.config[:yes] = true
+            run_knife(knife_cmd)
+
+            knife_cmd = Chef::Knife::ClientDelete.new
+            knife_cmd.name_args = [ name ]
+            knife_cmd.config[:yes] = true
+            run_knife(knife_cmd)
+
+        rescue Exception => msg
+            puts("\nError deleting node #{name} using knife config: #{msg}\n#{@knife_config.to_yaml}\n")
+            @logger.info(msg.backtrace.join("\n\t")) if @logger.debug
+
+            raise msg
+        end
+
+        def delete_vm(name, knife_config)
+            raise NotImplemented, 'HostNodeManager.delete_vm'
+        end
+
+        def config_knife(knife_cmd, options)
+
+            options.each_pair do |k, v|
+
+                arg = k.gsub(/-/, '_')
+
+                # Fix issue where '~/' is not expanded to home dir
+                v.gsub!(/~\//, Dir.home + '/') if arg.end_with?('_dir') && v.start_with?('~/')
+
+                knife_cmd.config[arg.to_sym] = v
+            end
+        end
+
+        private
+
+        def get_stack_node_resources
+
+            query = Chef::Search::Query.new
+
+            escaped_query = URI.escape(
+                "stack_id:#{@id} AND stack_node:#{@name}",
+                Regexp.new("[^#{URI::PATTERN::UNRESERVED}]") )
+
+            results = query.search('node', escaped_query, nil, 0, 999999)
+            @nodes = results[0]
+
+            results[2]
+        end
+
+        def set_attributes(name, attributes, key = nil)
+
+            attributes.each do |k, v|
+
+                if v.is_a?(Hash)
+                    set_attributes(name, v, key.nil? ? k : key + '.' + k)
+                else
+                    knife_cmd = KnifeAttribute::Node::NodeAttributeSet.new
+                    knife_cmd.name_args = [ name, (key.nil? ? k : key + '.' + k), v.to_s ]
+                    knife_cmd.config[:type] = 'override'
+                    run_knife(knife_cmd)
+                end
+            end
+        end
+
+        def knife_ssh(name, cmd)
+
+            sudo = @knife_config['options']['sudo'] ? 'sudo -i su -c ' : ''
+
+            ssh_cmd = "TMPFILE=`mktemp` && " +
+                "echo -e \"#{cmd.gsub(/\"/, "\\\"").gsub(/\$/, "\\$").gsub(/\`/, '\\' + '\`')}\" > $TMPFILE && " +
+                "chmod 0744 $TMPFILE && " +
+                "#{sudo}$TMPFILE && " +
+                "rm $TMPFILE"
+
+            knife_cmd = Chef::Knife::Ssh.new
+            knife_cmd.name_args = [ "name:#{name}", ssh_cmd ]
+            knife_cmd.config[:attribute] = 'ipaddress'
+
+            config_knife(knife_cmd, @knife_config['options'] || { })
+
+            if @logger.info? || @logger.debug?
+
+                output = StackBuilder::Common::TeeIO.new($stdout)
+                error = StackBuilder::Common::TeeIO.new($stderr)
+
+                @logger.info("Running '#{cmd}' on node 'name:#{name}'.")
+                run_knife(knife_cmd, 0, output, error)
+            else
+                run_knife(knife_cmd)
+            end
+        end
+
+    end
+end

data/lib/stackbuilder/chef/stack_provider.rb

@@ -0,0 +1,77 @@
+# Copyright (c) 2014 Mevan Samaratunga
+
+include StackBuilder::Common::Helpers
+
+module StackBuilder::Chef
+
+    class NodeProvider < StackBuilder::Stack::NodeProvider
+
+        def initialize(repo_path, environment)
+
+            @logger = StackBuilder::Common::Config.logger
+
+            @repo_path = File.expand_path(repo_path)
+            @environment = environment
+
+            env_file = "#{@repo_path}/etc/#{@environment}.yml"
+            if File.exist?(env_file)
+
+                @logger.debug( "Loading externalized environment variables from " +
+                  "'#{env_file}' and merging them with the current process environment." )
+
+                @env_vars = StackBuilder::Common.load_yaml(env_file, ENV)
+            else
+                @logger.warn( "No environment variable file '#{env_file}' " +
+                    "found. Continuing with empty environemnt variables")
+
+                @env_vars = { }
+            end
+        end
+
+        def set_stack(stack, id)
+
+            @stack = stack
+            @id = id
+
+            stack_environment = stack['environment']
+            raise ArgmentError, "Stack file is fixed to the environment '#{stack_environment}', " +
+                " which it does not match the environment '#{@environment}' provided." \
+                unless stack_environment.nil? || stack_environment==@environment
+
+            Chef::Config[:chef_server_url] = stack['chef_server_url'] if stack.has_key?('chef_server_url')
+            Chef::Config[:environment] = @environment
+        end
+
+        def get_env_vars
+            @env_vars
+        end
+
+        def get_node_manager(node_config)
+
+            knife_config = node_config['knife']
+            if knife_config.nil?
+                return StackBuilder::Chef::NodeManager.new(@id, node_config, @repo_path, @environment)
+
+            else
+                if knife_config.has_key?('plugin')
+
+                    case knife_config['plugin']
+                        when 'vagrant'
+                            return StackBuilder::Chef::VagrantNodeManager.new(@id, node_config, @repo_path, @environment)
+
+                        # TODO: Refactor so that managers are pluggable from other gems
+
+                        else
+                            raise ArgumentError, "Unknown plugin #{knife['plugin']}."
+                    end
+
+                elsif knife_config.has_key?('create')
+                    return StackBuilder::Chef::GenericNodeManager.new(@id, node_config, @repo_path, @environment)
+
+                else
+                    return StackBuilder::Chef::NodeManager.new(@id, node_config, @repo_path, @environment)
+                end
+            end
+        end
+    end
+end

data/lib/stackbuilder/chef/stack_vagrant_node.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2014 Mevan Samaratunga
+
+include StackBuilder::Common::Helpers
+
+module StackBuilder::Chef
+
+    class VagrantNodeManager < StackBuilder::Chef::NodeManager
+
+        def create_vm(name, knife_config)
+
+            knife_cmd = Chef::Knife::VagrantServerCreate.new
+
+            knife_cmd.config[:chef_node_name] = name
+
+            # Set the defaults
+            knife_cmd.config[:distro] = 'chef-full'
+            knife_cmd.config[:template_file] = false
+
+            knife_cmd.config[:vagrant_dir] = File.join(Dir.home, '/.vagrant')
+            knife_cmd.config[:provider] = 'virtualbox'
+            knife_cmd.config[:memsize] = 1024
+            knife_cmd.config[:subnet] = '192.168.67.0/24'
+            knife_cmd.config[:port_forward] = { }
+            knife_cmd.config[:share_folders] = [ ]
+            knife_cmd.config[:use_cachier] = false
+
+            knife_cmd.config[:host_key_verify] = false
+            knife_cmd.config[:ssh_user] = 'vagrant'
+            knife_cmd.config[:ssh_port] = '22'
+
+            config_knife(knife_cmd, knife_config['options'] || { })
+
+            ip_address = knife_cmd.config[:ip_address]
+            knife_cmd.config[:ip_address] = ip_address[/(\d+\.\d+\.\d+\.)/, 1] + \
+                (ip_address[/\.(\d+)\+/, 1].to_i + name[/-(\d+)$/, 1].to_i).to_s \
+                unless ip_address.nil? || !ip_address.end_with?('+')
+
+            @@sync ||= Mutex.new
+            @@sync.synchronize {
+                run_knife(knife_cmd)
+            }
+        end
+
+        def delete_vm(name, knife_config)
+
+            knife_cmd = Chef::Knife::VagrantServerDelete.new
+            knife_cmd.name_args = [ name ]
+            knife_cmd.config[:yes] = true
+            knife_cmd.config[:vagrant_dir] = File.join(Dir.home, '/.vagrant')
+
+            @@sync ||= Mutex.new
+            @@sync.synchronize {
+                run_knife(knife_cmd, 3)
+            }
+
+        rescue Exception => msg
+
+            if Dir.exist?(knife_cmd.config[:vagrant_dir] + '/' + name)
+
+                knife_cmd = Chef::Knife::VagrantServerList.new
+                knife_cmd.config[:vagrant_dir] = File.join(Dir.home, '/.vagrant')
+                server_list = run_knife(knife_cmd)
+
+                if server_list.lines.keep_if { |l| l=~/test-TEST-0/ }.first.chomp.end_with?('running')
+                    raise msg
+                else
+                    FileUtils.rm_rf(knife_cmd.config[:vagrant_dir] + '/' + name)
+                end
+            end
+        end
+    end
+end

data/lib/stackbuilder/common/config.rb

@@ -0,0 +1,44 @@
+# Copyright (c) 2014 Mevan Samaratunga
+
+module StackBuilder::Common
+    
+    class Config
+
+        CACHE_TIMEOUT = 60
+
+        class << self
+            extend Forwardable
+            def_delegators :@delegate, :logger, :timeouts, :enable_caching, :cachedir, :silent
+        end
+
+        def self.configure(config)
+            
+            config.silent = false
+            
+            # Determine timeouts
+            config.timeouts = { } if config.timeouts.nil?
+            config.timeouts[:CACHE_TIMEOUT] = CACHE_TIMEOUT unless config.timeouts.has_key?(:CACHE_TIMEOUT)
+            
+            # Create cache folder
+            config.enable_caching = false if config.enable_caching.nil?
+            if config.enable_caching
+                config.cachedir = File.expand_path(File.join(Dir.home, ".c2c_cache")) if config.cachedir.nil?
+                begin
+                    FileUtils.mkdir_p(config.cachedir) if !Dir.exists?(config.cachedir)
+                rescue
+                    self.logger.debug("could not create cachedir: #{config.cachedir}")
+                    config.enable_caching = false
+                    config.cachdir = nil
+                end
+            end
+            
+            @delegate = config
+            
+            self.logger.debug("Caching Enabled: #{config.enable_caching}; Cache Dir: #{self.cachedir}; Timeouts: #{self.timeouts}")
+        end
+        
+        def self.set_silent
+            @delegate.silent = true
+        end
+    end
+end

data/lib/stackbuilder/common/errors.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2014 Mevan Samaratunga
+
+module StackBuilder::Common
+
+    class StackBuilderError < StandardError; end
+    class InvalidArgs < StackBuilderError; end
+    class NotImplemented < StackBuilderError; end
+    class NotSupported < StackBuilderError; end
+
+    class StackCreateError < StackBuilderError; end
+    class StackOrchestrateError < StackBuilderError; end
+    class StackDeleteError < StackBuilderError; end
+
+    class CertificateError < StackBuilderError; end
+
+    class KnifeError < StackBuilderError; end
+    class BerksError < StackBuilderError; end
+end