knife-spork-berks 1.3.2

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

@@ -0,0 +1,118 @@
+require 'knife-spork/plugins/plugin'
+
+module KnifeSpork
+  module Plugins
+    class StatusNet < Plugin
+      name :statusnet
+
+      def perform; end
+
+      def after_upload
+        statusnet "#{organization}#{current_user} uploaded the following cookbooks:\n#{cookbooks.collect{ |c| "  #{c.name}@#{c.version}" }.join("\n")}"
+      end
+
+      def after_promote_remote
+        statusnet "#{organization}#{current_user} promoted the following cookbooks:\n#{cookbooks.collect{ |c| "  #{c.name}@#{c.version}" }.join("\n")} to #{environments.collect{ |e| "#{e.name}" }.join(", ")}"
+      end
+
+      def after_environmentfromfile
+        statusnet "#{organization}#{current_user} uploaded environment #{object_name}"
+      end
+
+      def after_environmentedit
+        statusnet "#{organization}#{current_user} edited environment #{object_name}"
+      end
+
+      def after_environmentcreate
+        statusnet "#{organization}#{current_user} created environment #{object_name}"
+      end
+
+      def after_environmentdelete
+        statusnet "#{organization}#{current_user} deleted environment #{object_name}"
+      end
+
+      def after_rolefromfile
+        statusnet "#{organization}#{current_user} uploaded role #{object_name}"
+      end
+
+      def after_roleedit
+        statusnet "#{organization}#{current_user} edited role #{object_name}"
+      end
+
+      def after_rolecreate
+        statusnet "#{organization}#{current_user} created role #{object_name}"
+      end
+
+      def after_roledelete
+        statusnet "#{organization}#{current_user} deleted role #{object_name}"
+      end
+
+      def after_databagedit
+        statusnet "#{organization}#{current_user} edited data bag item #{object_name}:#{object_secondary_name}"
+      end
+
+      def after_databagcreate
+        statusnet "#{organization}#{current_user} created data bag #{object_name}"
+      end
+
+      def after_databagdelete
+        statusnet "#{organization}#{current_user} deleted data bag #{object_name}"
+      end
+
+      def after_databagitemdelete
+        statusnet "#{organization}#{current_user} deleted data bag item #{object_name}:#{object_secondary_name}"
+      end
+
+      def after_databagfromfile
+        statusnet "#{organization}#{current_user} uploaded data bag item #{object_name}:#{object_secondary_name}"
+      end
+
+      def after_nodeedit
+        statusnet "#{organization}#{current_user} edited node #{object_name}"
+      end
+
+      def after_nodedelete
+        statusnet "#{organization}#{current_user} deleted node #{object_name}"
+      end
+
+      def after_nodecreate
+        statusnet "#{organization}#{current_user} created node #{object_name}"
+      end
+
+      def after_nodefromfile
+        statusnet "#{organization}#{current_user} uploaded node #{object_name}"
+      end
+
+      def after_noderunlistadd
+        statusnet "#{organization}#{current_user} added run_list items to #{object_name}: #{object_secondary_name}"
+      end
+
+      def after_noderunlistremove
+        statusnet "#{organization}#{current_user} removed run_list items from #{object_name}: #{object_secondary_name}"
+      end
+
+      def after_noderunlistset
+        statusnet "#{organization}#{current_user} set the run_list for #{object_name} to #{object_secondary_name}"
+      end
+
+      private
+
+      def statusnet(message)
+        safe_require 'curb'
+
+        begin
+          c = Curl::Easy.new(config.url)
+          c.http_auth_types = :basic
+          c.username = config.username
+          c.password = config.password
+          c.post_body = message
+          c.perform
+        rescue Exception => e
+          ui.error 'Something went wrong sending to StatusNet.'
+          ui.error e.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/knife-spork/runner.rb

@@ -0,0 +1,277 @@
+require 'app_conf'
+require 'diffy'
+require 'json'
+
+require 'chef/cookbook_loader'
+require 'chef/knife/core/object_loader'
+require 'knife-spork/plugins'
+
+begin
+  require 'berkshelf'
+rescue LoadError
+end
+
+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("#{cookbook_path.gsub('cookbooks','')}/config/spork-config.yml"), 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}
+
+        # Affects promote only:
+        # Set loaded cookbook version if the -v or --version parameter was specified
+        # Otherwise the version on disk, often more recent will be used.
+        # We know cookbooks will only contain one cookbook in the case of promote.
+        cookbooks.map{|c|c.version = config[:version]} if config[:version]
+
+        environments = [ @environments || @environment ].flatten.compact.collect{|environment| environment.is_a?(::Chef::Environment) ? environment : load_environment_from_file(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,
+          :environment_path => environment_path,
+          :cookbook_path => cookbook_path,
+          :object_name => @object_name,
+          :object_secondary_name => @object_secondary_name,
+          :object_difference => @object_difference,
+          :ui => ui
+        )
+      end
+
+      def load_environments_and_cookbook
+        ensure_environment_provided!
+
+        if @name_args.size == 2
+          environments = load_specified_environment_group(@name_args[0])
+          [ environments, @name_args[1] ]
+        elsif @name_args.size == 1
+          [ [default_environments].flatten, @name_args[0] ]
+        end
+      end
+
+      def load_specified_environment_group(name)
+        if !spork_config.environment_groups.nil? && spork_config.environment_groups.keys.include?(name)
+          spork_config.environment_groups[name]
+        else
+          [name]
+        end
+      end
+
+      def ensure_environment_provided!
+        if default_environments.empty? && @name_args.size < 2
+          ui.error('You must specify an environment or environment group and a cookbook name')
+          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 environment_loader
+        @environment_loader ||= Chef::Knife::Core::ObjectLoader.new(::Chef::Environment, ui)
+      end
+
+      def role_loader
+        @role_loader ||= Chef::Knife::Core::ObjectLoader.new(::Chef::Role, 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 environment_path
+        spork_config[:environment_path] || cookbook_path.gsub("/cookbooks","/environments")
+      end
+
+      def role_path
+        spork_config[:role_path] || cookbook_path.gsub("/cookbooks","/roles")
+      end
+
+      def all_cookbooks
+        ::Chef::CookbookLoader.new(::Chef::Config.cookbook_path)
+      end
+
+      def load_cookbook(name)
+        return name if name.is_a?(Chef::CookbookVersion)
+
+        cookbook = load_from_chef(name) || load_from_berkshelf(name) || load_from_librarian(name)
+
+        cookbook || raise(Chef::Exceptions::CookbookNotFound,
+          "Could not find cookbook '#{name}' in any of the sources!")
+      end
+
+      def load_from_chef(name)
+        all_cookbooks[name]
+      rescue Chef::Exceptions::CookbookNotFound,
+             Chef::Exceptions::CookbookNotFoundInRepo
+        nil
+      end
+
+      def load_from_berkshelf(name)
+        return unless defined?(::Berkshelf)
+        berksfile = ::Berkshelf::Berksfile.from_file(self.config[:berksfile])
+        lockfile = ::Berkshelf::Lockfile.new(berksfile)
+
+        raise Berkshelf::BerkshelfError, "LockFileNotFound" unless File.exists?(lockfile.filepath)
+
+        cookbook = Berkshelf.ui.mute {
+          self.config[:skip_dependencies] ||= false
+          berksfile.resolve(lockfile.find(name), {skip_dependencies: self.config[:skip_dependencies]})[:solution].first
+        }
+
+        # convert Berkshelf::CachedCookbook to Chef::CookbookVersion by loading the cookback at the
+        # full path returned by Berkshelf (since a cookbook of name `x` is  not necessarily in a
+        # local directory named `x`.)
+        cookbook_path = cookbook.path
+        chef_search_dir = ::File.dirname(cookbook_path)
+        cookbook_dirname = ::File.basename(cookbook_path)
+        ::Chef::CookbookLoader.new(chef_search_dir).load_cookbook(cookbook_dirname)
+
+      end
+
+      # @todo #opensource
+      def load_from_librarian(name)
+        # Your code here :)
+        nil
+      end
+
+      def load_cookbooks(cookbook_names)
+        cookbook_names = [cookbook_names].flatten
+        cookbook_names.collect{ |cookbook_name| load_cookbook(cookbook_name) }
+      end
+
+
+      def load_role_from_file(role_name)
+        role_loader.object_from_file("#{role_path}/#{role_name}.json")
+      end
+
+      def load_role(role_name)
+        Chef::Role.load(role_name)
+      end
+
+      def load_node(node)
+        Chef::Node.load(node)
+      end
+
+      def load_databag(bag)
+        Chef::DataBag.load(bag)
+      end
+
+      def load_databag_item(bag, item_name)
+        Chef::DataBagItem.load(bag, item_name)
+      end
+
+      def load_environment(environment_name)
+        Chef::Environment.load(environment_name)
+      end
+
+      def load_environment_from_file(environment_name)
+        environment_loader.object_from_file("#{environment_path}/#{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']
+        hash_diff remote_environment_versions, local_environment_versions
+      end
+
+      def json_diff(a, b)
+        pre_json =  JSON.parse(a.respond_to?(:to_json) ? a.to_json : a)
+        post_json =  JSON.parse(b.respond_to?(:to_json) ? b.to_json : b)
+        Diffy::Diff.new(JSON.pretty_generate(pre_json), JSON.pretty_generate(post_json), :diff=>"-U 3").to_s.gsub(/[()]/, '\\\\\0')
+      end
+
+      def hash_diff(hash, other)
+        hash.keys.inject({}) do |memo, key|
+          unless hash[key] == other[key]
+            memo[key] = "#{hash[key]} changed to #{other[key]}"
+          end
+          memo
+        end
+      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(k,v)]}]
+      end
+
+      def calc_diff(cookbook, version)
+        components =  version.map{|v|v.split(".")}
+
+        if components.length < 2
+          ui.warn "#{cookbook} has no remote version to diff against!"
+          return 0
+        end
+
+        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

data/plugins/Campfire.md

@@ -0,0 +1,43 @@
+Campfire
+========
+Automatically posts informational messages to Campfire
+
+Gem Requirements
+----------------
+This plugin requires the following gems:
+
+```ruby
+gem 'campy'
+```
+
+Hooks
+-----
+- `after_promote`
+- `after_upload`
+
+Configuration
+-------------
+```yaml
+plugins:
+  campfire:
+    account: my_company
+    token: ABC123
+    rooms:
+      - General
+      - Web Operations
+```
+
+#### account
+This is your campfire account name. It is the subdomain part of your account.
+
+- Type: `String`
+
+#### token
+This is the secure token you get from the Campfire configuration.
+
+- Type: `String`
+
+#### Rooms
+This is an array of room names to post messages to.
+
+- Type: `String`

data/plugins/Eventinator.md

@@ -0,0 +1,30 @@
+Eventinator
+===========
+
+Gem Requirements
+----------------
+This plugin has no gem requirements.
+
+Hooks
+-----
+- `after_upload`
+
+Configuration
+-------------
+```yaml
+plugins:
+  eventinator:
+    url: www.example.com
+    read_timeout: 5
+```
+
+#### url
+The server to post to.
+
+- Type: `String`
+
+#### read_timeout
+The timeout, in seconds, for the request to return.
+
+- Type: `Integer`
+- Default: `5`