knife-spork 0.1.11 → 1.0.0

data/lib/knife-spork/plugins/eventinator.rb

@@ -0,0 +1,71 @@
+require 'knife-spork/plugins/plugin'
+require 'json'
+require 'uri'
+
+module KnifeSpork
+  module Plugins
+    class Eventinator < Plugin
+      name :eventinator
+
+      def perform; end
+
+      def after_upload
+        cookbooks.each do |cookbook|
+          event_data = {
+            :tag => 'knife',
+            :username => current_user,
+            :status => "#{current_user} has uploaded and frozen #{cookbook.name}@#{cookbook.version}",
+            :metadata => {
+              :cookbook_name => cookbook.name,
+              :cookbook_version => cookbook.version
+            }.to_json
+          }
+          eventinate(event_data)
+        end
+      end
+
+      def after_promote_remote
+        environments.each do |environment|
+          cookbooks.each do |cookbook|
+            event_data = {
+              :tag => 'knife',
+              :username => current_user,
+              :status => "#{current_user} has promoted #{cookbook.name}(#{cookbook.version}) to #{environment.name}",
+              :metadata => {
+                :cookbook_name => cookbook.name,
+                :cookbook_version => cookbook.version
+              }.to_json
+            }
+            eventinate(event_data)
+          end
+        end
+      end
+
+      def eventinate(event_data)
+        begin
+            uri = URI.parse(config.url)
+          rescue Exception => e
+            ui.error 'Could not parse URI for Eventinator.'
+            ui.error e.to_s
+            return
+          end
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.read_timeout = config.read_timeout || 5
+
+          request = Net::HTTP::Post.new(uri.request_uri)
+          request.set_form_data(event_data)
+
+          begin
+            response = http.request(request)
+            ui.error "Eventinator at #{config.url} did not receive a good response from the server" if response.code != '200'
+          rescue Timeout::Error
+            ui.error "Eventinator timed out connecting to #{config.url}. Is that URL accessible?"
+          rescue Exception => e
+            ui.error 'Eventinator error.'
+            ui.error e.to_s
+          end
+      end
+    end
+  end
+end

data/lib/knife-spork/plugins/foodcritic.rb

@@ -0,0 +1,41 @@
+require 'knife-spork/plugins/plugin'
+
+module KnifeSpork
+  module Plugins
+    class Foodcritic < Plugin
+      name :foodcritic
+      hooks :after_check, :before_upload
+
+      def perform
+        safe_require 'foodcritic'
+
+        tags = config.tags || []
+        fail_tags = config.fail_tags || ['any']
+        include_rules = config.include_rules || []
+
+        cookbooks.each do |cookbook|
+          ui.info "Running foodcritic against #{cookbook.name}@#{cookbook.version}..."
+
+          cookbook_path = cookbook.root_dir
+
+          ui.info cookbook_path
+          
+          options = {:tags => tags, :fail_tags => fail_tags, :include_rules => include_rules}
+          review = ::FoodCritic::Linter.new.check([cookbook_path], options)
+
+          if review.failed?
+            ui.error "Foodcritic failed!"
+            review.to_s.split("\n").each{ |r| ui.error r.to_s }
+            exit(1) if config.epic_fail
+          else
+            ui.info "Passed!"
+          end
+        end
+      end
+
+      def epic_fail?
+        config.epic_fail.nil? ? 'true' : config.epic_fail
+      end
+    end
+  end
+end

data/lib/knife-spork/plugins/git.rb

@@ -0,0 +1,123 @@
+require 'knife-spork/plugins/plugin'
+
+module KnifeSpork
+  module Plugins
+    class Git < Plugin
+      name :git
+
+      def perform; end
+
+      def before_bump
+        git_pull
+        git_pull_submodules
+      end
+
+      def before_upload
+        git_pull
+        git_pull_submodules
+      end
+
+      def before_promote
+        git_pull
+        git_pull_submodules
+      end
+
+      def after_bump
+        cookbooks.each do |cookbook|
+          git_add("#{cookbook.root_dir}/metadata.rb")
+        end
+      end
+
+      def after_promote_local
+        environments.each do |environment|
+          git_add("./environments/#{environment}.json")
+        end
+      end
+
+      private
+      def git
+        safe_require 'git'
+        log = Logger.new(STDOUT)
+        log.level = Logger::WARN
+        @git ||= begin
+          ::Git.open('.', :log => log)
+        rescue
+          ui.error 'You are not currently in a git repository. Ensure you are in the proper working directory or remove the git plugin from your KnifeSpork configuration!'
+          exit(0)
+        end
+      end
+
+      # In this case, a git pull will:
+      #   - Stash local changes
+      #   - Pull from the remote
+      #   - Pop the stash
+      def git_pull
+        ui.msg "Pulling latest changes from remote Git repo."
+        begin
+          git.fetch(remote)
+          git.merge("#{remote}/#{branch}")
+        rescue ::Git::GitExecuteError => e
+          ui.error "Could not pull from remote #{remote}/#{branch}. Does it exist?"
+        end
+      end
+
+      def git_pull_submodules
+        ui.msg "Pulling latest changes from git submodules (if any)"
+        output = IO.popen ("git submodule foreach git pull 2>&1")
+        Process.wait
+        exit_code = $?
+        if !exit_code.exitstatus ==  0
+            ui.error "#{output.read()}\n"
+            exit 1
+        end
+      end
+      
+      def git_add(filepath)
+       begin
+          ui.msg "Git add'ing #{filepath}"
+          git.add("#{filepath}")
+        rescue ::Git::GitExecuteError => e
+          ui.error "Git: Something went wrong with git add #{filepath}. Please try running git add manually."
+        end
+      end
+      
+      # Commit changes, if any
+      def git_commit
+        begin
+          git.add('.')
+          `git ls-files --deleted`.chomp.split("\n").each{ |f| git.remove(f) }
+          git.commit_all "[KnifeSpork] Bumping cookbooks:\n#{cookbooks.collect{|c| "  #{c.name}@#{c.version}"}.join("\n")}"
+        rescue ::Git::GitExecuteError; end
+      end
+
+      def git_push(tags = false)
+        begin
+          git.push remote, branch, tags
+        rescue ::Git::GitExecuteError => e
+          ui.error "Could not push to remote #{remote}/#{branch}. Does it exist?"
+        end
+      end
+
+      def git_tag(tag)
+        begin
+          git.add_tag(tag)
+        rescue ::Git::GitExecuteError => e
+          ui.error "Could not tag #{tag_name}. Does it already exist?"
+          ui.error 'You may need to delete the tag before running promote again.'
+        end
+      end
+
+      def remote
+        config.remote || 'origin'
+      end
+
+      def branch
+        config.branch || 'master'
+      end
+
+      def tag_name
+        cookbooks.collect{|c| "#{c.name}@#{c.version}"}.join('-')
+      end
+    end
+  end
+end

data/lib/knife-spork/plugins/graphite.rb

@@ -0,0 +1,25 @@
+require 'knife-spork/plugins/plugin'
+
+module KnifeSpork
+  module Plugins
+    class Graphite < Plugin
+      name :graphite
+      hooks :after_promote_remote
+
+      def perform
+        environments.each do |environment|
+          begin
+            message = "deploys.chef.#{environment} 1 #{Time.now.to_i}\n"
+            socket = TCPSocket.open(config.server, config.port)
+            socket.write(message)
+          rescue Exception => e
+            ui.error 'Graphite was unable to process the request.'
+            ui.error e.to_s
+          ensure
+            socket.close unless socket.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-spork/plugins/hip_chat.rb

@@ -0,0 +1,50 @@
+require 'knife-spork/plugins/plugin'
+
+module KnifeSpork
+  module Plugins
+    class HipChat < Plugin
+      name :hip_chat
+
+      def perform; end
+
+      def after_upload
+        hipchat "#{current_user} uploaded the following cookbooks:\n#{cookbooks.collect{ |c| "  #{c.name}@#{c.version}" }.join("\n")}"
+      end
+
+      def after_promote_remote
+        hipchat "#{current_user} promoted the following cookbooks:\n#{cookbooks.collect{ |c| "  #{c.name}@#{c.version}" }.join("\n")} to #{environments.collect{ |e| "#{e.name}" }.join(", ")}"
+      end
+
+      private
+      def hipchat(message)
+        safe_require 'hipchat'
+
+        rooms.each do |room_name|
+          begin
+            client = ::HipChat::Client.new(config.api_token)
+            client[room_name].send(nickname, message, notify:notify, color:color)
+          rescue Exception => e
+            ui.error 'Something went wrong sending to HipChat.'
+            ui.error e.to_s
+          end
+        end
+      end
+
+      def rooms
+        [ config.room || config.rooms ].flatten
+      end
+
+      def nickname
+        config.nickname || 'KnifeSpork'
+      end
+
+      def notify
+        config.notify.nil? ? true : config.notify
+      end
+
+      def color
+        config.color || 'yellow'
+      end
+    end
+  end
+end

data/lib/knife-spork/plugins/irccat.rb

@@ -0,0 +1,48 @@
+require 'knife-spork/plugins/plugin'
+
+module KnifeSpork
+  module Plugins
+    class Irccat < Plugin
+      name :irccat
+
+      def perform; end
+
+      def after_upload
+        irccat("#BOLD#PURPLECHEF:#NORMAL #{current_user} uploaded #TEAL#{cookbooks.collect{ |c| "#{c.name}@#{c.version}" }.join(", ")}#NORMAL")
+      end
+
+      def after_promote_remote
+        environments.each do |environment|
+          diff = environment_diffs[environment.name]
+          env_gist = gist(environment, diff) if config.gist
+          irccat("#BOLD#PURPLECHEF:#NORMAL #{current_user} promoted #TEAL#{cookbooks.collect{ |c| "#{c.name}@#{c.version}" }.join(", ")}#NORMAL to #{environment.name} #{env_gist}")
+        end
+      end
+
+      private
+      def irccat(message)
+        channels.each do |channel|
+          begin
+            # Write the message using a TCP Socket
+            socket = TCPSocket.open(config.server, config.port)
+            socket.write("#{channel} #{message}")
+          rescue Exception => e
+            ui.error 'Failed to post message with irccat.'
+            ui.error e.to_s
+          ensure
+            socket.close unless socket.nil?
+          end
+        end
+      end
+
+      def gist(environment, diff)
+        msg = "Environment #{environment} uploaded at #{Time.now.getutc} by #{current_user}\n\nConstraints updated on server in this version:\n\n#{diff.collect { |k, v| "#{k}: #{v}\n" }.join}"
+        %x[ echo "#{msg}" | #{config.gist}]
+      end
+      
+      def channels
+        [ config.channel || config.channels ].flatten
+      end
+    end
+  end
+end

data/lib/knife-spork/plugins/plugin.rb

@@ -0,0 +1,74 @@
+module KnifeSpork
+  module Plugins
+    class Plugin
+      # This is the name of the plugin. It must correspond to the name in the yaml configuration
+      # file in order to load this plugin. If an attribute is passed in, the name is set to that
+      # given value. Otherwise, the name is returned.
+      def self.name(name = nil)
+        if name.nil?
+          class_variable_get(:@@name)
+        else
+          class_variable_set(:@@name, name)
+        end
+      end
+
+      # This is a convenience method for defining multiple hooks in a single call.
+      def self.hooks(*the_hooks)
+        [the_hooks].flatten.each{ |the_hook| hook(the_hook) }
+      end
+
+      # When defining a hook, we define a method on the instance that corresponds to that
+      # hook. That will be fired when the hook is fired.
+      def self.hook(the_hook)
+        self.send(:define_method, the_hook.to_sym) do
+          perform
+        end
+      end
+
+      def initialize(options = {})
+        @options = {
+          :payload => {}
+        }.merge(options)
+      end
+
+      def enabled?
+        !config.nil?
+      end
+
+      private
+      def config
+        @options[:config].plugins.send(self.class.name.to_sym)
+      end
+
+      def cookbooks
+        @options[:cookbooks]
+      end
+
+      def environments
+        @options[:environments]
+      end
+
+      def environment_diffs
+        @options[:environment_diffs]
+      end
+
+      def ui
+        @options[:ui]
+      end
+
+      def current_user
+        (begin `git config user.name`.chomp; rescue nil; end || ENV['USERNAME'] || ENV['USER']).strip
+      end
+
+      # Wrapper method around require that attempts to include the associated file. If it does not exist
+      # or cannot be loaded, an nice error is produced instead of blowing up.
+      def safe_require(file)
+        begin
+          require file
+        rescue LoadError
+          raise "You are using a plugin for knife-spork that requires #{file}, but you have not installed it. Please either run \"gem install #{file}\", add #{file} to your Gemfile or remove the plugin from your configuration."
+        end
+      end
+    end
+  end
+end

data/lib/knife-spork/runner.rb

@@ -0,0 +1,166 @@
+require 'app_conf'
+require 'json'
+
+require 'chef/cookbook_loader'
+require 'chef/knife/core/object_loader'
+require 'knife-spork/plugins'
+
+module KnifeSpork
+  module Runner
+    module ClassMethods; end
+
+    module InstanceMethods
+      def spork_config
+        return @spork_config unless @spork_config.nil?
+
+        @spork_config = AppConf.new
+        load_paths = [ File.expand_path('config/spork-config.yml'), '/etc/spork-config.yml', File.expand_path('~/.chef/spork-config.yml') ]
+        load_paths.each do |load_path|
+          if File.exists?(load_path)
+            @spork_config.load(load_path)
+          end
+        end
+
+        @spork_config
+      end
+
+      def run_plugins(hook)
+        cookbooks = [ @cookbooks || @cookbook ].flatten.compact.collect{|cookbook| cookbook.is_a?(::Chef::CookbookVersion) ? cookbook : load_cookbook(cookbook)}.sort{|a,b| a.name.to_s <=> b.name.to_s}
+        environments = [ @environments || @environment ].flatten.compact.collect{|environment| environment.is_a?(::Chef::Environment) ? environment : load_environment(environment)}.sort{|a,b| a.name.to_s <=> b.name.to_s}
+        environment_diffs = @environment_diffs
+        
+        KnifeSpork::Plugins.run(
+          :config => spork_config,
+          :hook => hook.to_sym,
+          :cookbooks => cookbooks,
+          :environments => environments,
+          :environment_diffs => environment_diffs,
+          :ui => ui
+        )
+      end
+
+      def load_environments_and_cookbook
+        ensure_environment_provided!
+
+        if @name_args.size == 2
+          [ [@name_args[0]].flatten, @name_args[1] ]
+        elsif @name_args.size == 1
+          [ [default_environments].flatten, @name_args[0] ]
+        end
+      end
+
+      def ensure_environment_provided!
+        if default_environments.empty? && @name_args.size < 2
+          ui.error('You must specify a cookbook name and an environment')
+          exit(1)
+        end
+      end
+
+      def default_environments
+        [ spork_config.default_environment || spork_config.default_environments ].flatten.compact
+      end
+
+      def pretty_print_json(json)
+        JSON.pretty_generate(json)
+      end
+
+      def valid_version?(version)
+        version_keys = version.split('.')
+        return false unless version_keys.size == 3 && version_keys.any?{ |k| begin Float(k); rescue false; else true; end }
+        true
+      end
+
+      def validate_version!(version)
+        if version && !valid_version?(version)
+          ui.error("#{version} is not a valid version!")
+          exit(1)
+        end
+      end
+
+      def loader
+        @loader ||= Chef::Knife::Core::ObjectLoader.new(::Chef::Environment, ui)
+      end
+
+      # It's not feasible to try and "guess" which cookbook path to use, so we will
+      # always just use the first one in the path.
+      def cookbook_path
+        ensure_cookbook_path!
+        [config[:cookbook_path] ||= ::Chef::Config.cookbook_path].flatten[0]
+      end
+
+      def all_cookbooks
+        ::Chef::CookbookLoader.new(::Chef::Config.cookbook_path)
+      end
+
+      def load_cookbook(cookbook_name)
+        return cookbook_name if cookbook_name.is_a?(::Chef::CookbookVersion)
+        loader = ::Chef::CookbookLoader.new(Chef::Config.cookbook_path)
+        loader[cookbook_name]
+      end
+
+      def load_cookbooks(cookbook_names)
+        cookbook_names = [cookbook_names].flatten
+        cookbook_names.collect{ |cookbook_name| load_cookbook(cookbook_name) }
+      end
+
+      def load_environment(environment_name)
+        loader.load_from('environments', "#{environment_name}.json")
+      end
+
+      def load_remote_environment(environment_name)
+        begin
+          Chef::Environment.load(environment_name)
+        rescue Net::HTTPServerException => e
+          ui.error "Could not load #{environment_name} from Chef Server. You must upload the environment manually the first time."
+          exit(1)
+        end      
+      end
+
+      def environment_diff (local_environment, remote_environment)
+          local_environment_versions = local_environment.to_hash['cookbook_versions']
+          remote_environment_versions = remote_environment.to_hash['cookbook_versions']
+          remote_environment_versions.diff(local_environment_versions)
+      end
+      
+      def constraints_diff (environment_diff)
+        Hash[Hash[environment_diff.map{|k,v| [k, v.split(" changed to ").map{|x|x.gsub("= ","")}]}].map{|k,v|[k,calc_diff(v)]}]
+      end
+      
+      def calc_diff(version)
+        components =  version.map{|v|v.split(".")}
+        if components[1][0].to_i != components[0][0].to_i
+          return (components[1][0].to_i - components[0][0].to_i)*100
+        elsif components[1][1].to_i != components[0][1].to_i
+          return (components[1][1].to_i - components[0][1].to_i)*10
+        else
+          return (components[1][2].to_i - components[0][2].to_i)
+        end
+      end
+      
+      def ensure_cookbook_path!
+        if !config.has_key?(:cookbook_path)
+          ui.fatal "No default cookbook_path; Specify with -o or fix your knife.rb."
+          show_usage
+          exit(1)
+        end
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend(ClassMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+  end
+end
+
+
+class Hash
+  def diff(other)
+    self.keys.inject({}) do |memo, key|
+      unless self[key] == other[key]
+        memo[key] = "#{self[key]} changed to #{other[key]}"
+      end
+      memo
+    end
+  end
+end