chef_handler_foreman 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f732d147f13678919bd92180c402f03a1557cd3
+  data.tar.gz: 5fb453eeffa51588e2931ea9ebd9ee4d24075902
+SHA512:
+  metadata.gz: 34dd72612b5e564bddd19caea1f5cacedc4ad98c111787185940737f665b0faa6a41684eb5e734eebbc0b1fb149581e6cffa694530ba5242383cda7b00ee2c08
+  data.tar.gz: a50c75a58979130d250e2ddaf97073458937649099e73ea6307695e4f58031f33ea3011e087b0d016a1a79e003d8bdbd0aa23fe0627d5d8776df7719065c1ac7

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Marek Hulan
+
+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/README.md

@@ -0,0 +1,31 @@
+# Description
+
+This gem adds Chef report and attributes handlers that send reports to TheForeman Project.
+You need Foreman 1.3+ to use it.
+See: http://www.theforeman.org
+
+## Installation
+
+
+Since it's released as a gem you can simply run
+```sh
+# gem install chef_foreman_handler
+```
+## Usage:
+
+In /etc/chef/config.rb:
+
+```ruby
+# this adds new functions to chef configuration
+require 'chef_handler_foreman'
+# here you can specify your connection options
+foreman_server_options  :url => 'http://your.server/foreman'
+# add following line if you want to upload node attributes (facts in Foreman language)
+foreman_facts_upload    true
+# add following line if you want to upload reports
+foreman_reports_upload  true
+```
+
+You can also specify a second argument to foreman_reports_upload which is a number:
+- 1 (default) for reporter based on more detailed ResourceReporter
+- 2 not so verbose based just on run_status, actually just counts applied resources

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/chef_handler_foreman.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef_handler_foreman/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "chef_handler_foreman"
+  spec.version       = ChefHandlerForeman::VERSION
+  spec.authors       = ["Marek Hulan"]
+  spec.email         = ["mhulan@redhat.com"]
+  spec.description   = %q{Chef handlers to integrate with foreman}
+  spec.summary       = %q{This gem adds chef handlers so your chef-client can upload attributes (facts) and reports to Foreman}
+  spec.homepage      = "https://github.com/theforeman/chef-handler-foreman"
+  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 = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/chef_handler_foreman.rb

@@ -0,0 +1,5 @@
+require "chef_handler_foreman/version"
+require 'chef'
+require 'chef_handler_foreman/foreman_hooks'
+
+Chef::Config.send :extend, ChefHandlerForeman::ForemanHooks

data/lib/chef_handler_foreman/foreman_facts.rb

@@ -0,0 +1,75 @@
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program.  If not, see <http://www.gnu.org/licenses/>
+
+require 'chef/handler'
+
+module ChefHandlerForeman
+  class ForemanFacts < Chef::Handler
+    attr_accessor :uploader
+
+    def report
+      send_attributes(prepare_facts)
+    end
+
+    private
+
+    def prepare_facts
+      { :name  => node.name,
+        :facts => plain_attributes.merge({
+                                             :operatingsystem        => node.lsb[:id],
+                                             :operatingsystemrelease => node.lsb.release,
+                                             :_timestamp             => Time.now,
+                                             :_type                  => 'foreman_chef'
+                                         })
+      }
+    end
+
+    def plain_attributes
+      plainify(node.attributes.to_hash).flatten.inject(&:merge)
+    end
+
+    def plainify(hash, prefix = nil)
+      result = []
+      hash.each_pair do |key, value|
+        if value.is_a?(Hash)
+          result.push plainify(value, get_key(key, prefix))
+        elsif value.is_a?(Array)
+          result.push plainify(array_to_hash(value), get_key(key, prefix))
+        else
+          new                       = {}
+          new[get_key(key, prefix)] = value
+          result.push new
+        end
+      end
+      result
+    end
+
+    def array_to_hash(array)
+      new = {}
+      array.each_with_index { |v, index| new[index.to_s] = v }
+      new
+    end
+
+    def get_key(key, prefix)
+      [prefix, key].compact.join('::')
+    end
+
+    def send_attributes(attributes)
+      if uploader
+        uploader.foreman_request('/api/hosts/facts', attributes, node.name)
+      else
+        Chef::Log.error "No uploader registered for foreman facts, skipping facts upload"
+      end
+    end
+  end
+end

data/lib/chef_handler_foreman/foreman_hooks.rb

@@ -0,0 +1,45 @@
+require 'chef_handler_foreman/foreman_facts'
+require 'chef_handler_foreman/foreman_reporting'
+require 'chef_handler_foreman/foreman_resource_reporter'
+require 'chef_handler_foreman/foreman_uploader'
+
+module ChefHandlerForeman
+  module ForemanHooks
+    # {:url => '', ...}
+    def foreman_server_options(options)
+      { :client_key => client_key || '/etc/chef/client.pem' }.merge(options)
+      @foreman_uploader = ForemanUploader.new(options)
+    end
+
+    def foreman_facts_upload(upload)
+      if upload
+        foreman_facts_handler          = ForemanFacts.new
+        foreman_facts_handler.uploader = @foreman_uploader
+        report_handlers << foreman_facts_handler
+        exception_handlers << foreman_facts_handler
+      end
+    end
+
+    def foreman_reports_upload(upload, mode = 1)
+      if upload
+        case mode
+          when 1
+            foreman_reporter          = ForemanResourceReporter.new(nil)
+            foreman_reporter.uploader = @foreman_uploader
+            if Chef::Config[:event_handlers].is_a?(Array)
+              Chef::Config[:event_handlers].push foreman_reporter
+            else
+              Chef::Config[:event_handlers] = [foreman_reporter]
+            end
+          when 2
+            foreman_handler          = ForemanReporting.new
+            foreman_handler.uploader = uploader
+            report_handlers << foreman_handler
+            exception_handlers << foreman_handler
+          else
+            raise ArgumentError, 'unknown mode: ' + mode.to_s
+        end
+      end
+    end
+  end
+end

data/lib/chef_handler_foreman/foreman_reporting.rb

@@ -0,0 +1,90 @@
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program.  If not, see <http://www.gnu.org/licenses/>
+
+require 'chef/handler'
+
+module ChefHandlerForeman
+  class ForemanReporting < ::Chef::Handler
+    attr_accessor :uploader
+
+    def report
+      report                   = { 'host' => node.fqdn, 'reported_at' => Time.now.utc.to_s }
+      report_status            = Hash.new(0)
+
+
+      report_status['failed']  = 1 if failed?
+      report_status['applied'] = run_status.updated_resources.count
+      report['status']         = report_status
+
+      # I can't compute much metrics for now
+      metrics                  = {}
+      metrics['resources']     = { 'total' => run_status.all_resources.count }
+
+      times = {}
+      run_status.all_resources.each do |resource|
+        resource_name = resource.resource_name
+        if times[resource_name].nil?
+          times[resource_name] = resource.elapsed_time
+        else
+          times[resource_name] += resource.elapsed_time
+        end
+      end
+      metrics['time']   = times.merge!({ 'total' => run_status.elapsed_time })
+      report['metrics'] = metrics
+
+      logs = []
+      run_status.updated_resources.each do |resource|
+        l = { 'log' => { 'sources' => {}, 'messages' => {}, 'level' => 'notice' } }
+
+        case resource.resource_name.to_s
+          when 'template', 'cookbook_file'
+            message = resource.diff
+          when 'package'
+            message = "Installed #{resource.package_name} package in #{resource.version}"
+          else
+            message = resource.action.to_s
+        end
+        l['log']['messages']['message'] = message
+        l['log']['sources']['source']   = [resource.resource_name.to_s, resource.name].join(' ')
+        #Chef::Log.info("Diff is #{l['log']['messages']['message']}")
+        logs << l
+      end
+
+      # I only set failed to 1 if chef run failed
+      if failed?
+        logs << {
+            'log' => {
+                'sources'  => { 'source' => 'chef' },
+                'messages' => { 'message' => run_status.exception },
+                'level'    => 'err' }
+        }
+      end
+
+      report['logs'] = logs
+      full_report    = { 'report' => report }
+
+      send_report(full_report)
+    end
+
+    private
+
+    def send_report(report)
+      if uploader
+        uploader.foreman_request('/api/reports', report, node.name)
+      else
+        Chef::Log.error "No uploader registered for foreman reporting, skipping report upload"
+      end
+
+    end
+  end
+end

data/lib/chef_handler_foreman/foreman_resource_reporter.rb

@@ -0,0 +1,155 @@
+module ChefHandlerForeman
+  class ForemanResourceReporter < ::Chef::ResourceReporter
+    attr_accessor :uploader
+
+    def initialize(*args)
+      @total_up_to_date     = 0
+      @total_skipped        = 0
+      @total_updated        = 0
+      @total_failed         = 0
+      @total_restarted      = 0
+      @total_failed_restart = 0
+      @all_resources        = []
+      super
+    end
+
+    def run_started(run_status)
+      @run_status = run_status
+    end
+
+    def run_completed(node)
+      @status = "success"
+      post_reporting_data
+    end
+
+    def run_failed(exception)
+      @exception = exception
+      @status    = "failure"
+      # If we failed before we received the run_started callback, there's not much we can do
+      # in terms of reporting
+      if @run_status
+        post_reporting_data
+      end
+    end
+
+    def resource_current_state_loaded(new_resource, action, current_resource)
+      super
+      @all_resources.push @pending_update unless @pending_update.nil?
+    end
+
+
+    def resource_up_to_date(new_resource, action)
+      @total_up_to_date += 1
+      super
+    end
+
+    def resource_skipped(resource, action, conditional)
+      @total_skipped += 1
+      super
+    end
+
+    def resource_updated(new_resource, action)
+      @total_updated   += 1
+      @total_restarted += 1 if action.to_s == 'restart'
+      super
+    end
+
+    def resource_failed(new_resource, action, exception)
+      @total_failed         += 1
+      @total_failed_restart += 1 if action.to_s == 'restart'
+      super
+    end
+
+    def resource_completed(new_resource)
+      if @pending_update && !nested_resource?(new_resource)
+        @pending_update.finish
+        @updated_resources << @pending_update
+        @pending_update = nil
+      end
+    end
+
+    def post_reporting_data
+      if reporting_enabled?
+        run_data = prepare_run_data
+        Chef::Log.info("Sending resource update report to foreman (run-id: #{@run_id})")
+        Chef::Log.debug run_data.inspect
+        begin
+          Chef::Log.debug("Sending data...")
+          if uploader
+            uploader.foreman_request('/api/reports', { "report" => run_data }, node.name)
+          else
+            Chef::Log.error "No uploader registered for foreman reporting, skipping report upload"
+          end
+        rescue => e
+          Chef::Log.error "Sending failed with #{e.class} #{e.message}"
+          Chef::Log.error e.backtrace.join("\n")
+        end
+      else
+        Chef::Log.debug("Reporting disabled, skipping report upload")
+      end
+    end
+
+    def prepare_run_data
+      run_data                = {}
+      run_data["host"]        = node_name
+      run_data["reported_at"] = end_time.to_s
+      run_data["status"]      = resources_per_status
+
+      run_data["metrics"] = {
+          "resources" => { "total" => @total_res_count },
+          "time"      => resources_per_time
+      }
+
+      run_data["logs"] = resources_logs + [chef_log]
+      run_data
+    end
+
+    def resources_per_status
+      { "applied"         => @total_updated,
+        "restarted"       => @total_restarted,
+        "failed"          => @total_failed,
+        "failed_restarts" => @total_failed_restart,
+        "skipped"         => @total_skipped,
+        "pending"         => 0
+      }
+    end
+
+    def resources_per_time
+      @run_status.all_resources.inject({}) do |memo, resource|
+        name, time = resource.resource_name.to_s, resource.elapsed_time || 0
+        memo[name] = memo[name] ? memo[name] + time : time
+        memo
+      end
+    end
+
+    def resources_logs
+      @all_resources.map do |resource|
+        action  = resource.new_resource.action
+        message = action.is_a?(Array) ? action.first.to_s : action.to_s
+        message += " (#{resource.exception.class} #{resource.exception.message})" unless resource.exception.nil?
+        { "log" => {
+            "sources"  => { "source" => resource.new_resource.to_s },
+            "messages" => { "message" => message },
+            "level"    => resource.exception.nil? ? "notice" : 'err'
+        } }
+      end
+    end
+
+    def chef_log
+      message = 'run'
+      if @status == 'success' && exception.nil?
+        level = 'notice'
+      else
+        message += " (#{exception.class} #{exception.message})"
+        level   = 'err'
+      end
+
+      { "log" => {
+          "sources"  => { "source" => 'Chef' },
+          "messages" => { "message" => message },
+          "level"    => level
+      } }
+    end
+
+  end
+end

data/lib/chef_handler_foreman/foreman_uploader.rb

@@ -0,0 +1,64 @@
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program.  If not, see <http://www.gnu.org/licenses/>
+
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'openssl'
+require 'digest/sha2'
+require 'base64'
+
+module ChefHandlerForeman
+  class ForemanUploader
+    attr_reader :options
+
+    def initialize(opts)
+      @options = opts
+    end
+
+    def foreman_request(path, body, client_name)
+      uri              = URI.parse(options[:url])
+      http             = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl     = uri.scheme == 'https'
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      if http.use_ssl?
+        if options[:foreman_ssl_ca] && !options[:foreman_ssl_ca].empty?
+          http.ca_file     = options[:foreman_ssl_ca]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        if options[:foreman_ssl_cert] && !options[:foreman_ssl_cert].empty? && options[:foreman_ssl_key] && !options[:foreman_ssl_key].empty?
+          http.cert = OpenSSL::X509::Certificate.new(File.read(options[:foreman_ssl_cert]))
+          http.key  = OpenSSL::PKey::RSA.new(File.read(options[:foreman_ssl_key]), nil)
+        end
+      end
+
+      req = Net::HTTP::Post.new("#{uri.path}/#{path}")
+      req.add_field('Accept', 'application/json,version=2')
+      req.content_type = 'application/json'
+      body_json        = body.to_json
+      req.body         = body_json
+      req.add_field('X-Foreman-Signature', sign_request(body_json, options[:client_key]))
+      req.add_field('X-Foreman-Client', client_name)
+      response         = http.request(req)
+    end
+
+    def sign_request(body_json, key_path)
+      hash_body = Digest::SHA256.hexdigest(body_json)
+      key = OpenSSL::PKey::RSA.new(File.read(key_path))
+      # Base64.encode64 is adding \n in the string
+      signature = Base64.encode64(key.sign(OpenSSL::Digest::SHA256.new, hash_body)).gsub("\n",'')
+    end
+  end
+end

data/lib/chef_handler_foreman/version.rb

@@ -0,0 +1,3 @@
+module ChefHandlerForeman
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: chef_handler_foreman
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marek Hulan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Chef handlers to integrate with foreman
+email:
+- mhulan@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- chef_handler_foreman.gemspec
+- lib/chef_handler_foreman.rb
+- lib/chef_handler_foreman/foreman_facts.rb
+- lib/chef_handler_foreman/foreman_hooks.rb
+- lib/chef_handler_foreman/foreman_reporting.rb
+- lib/chef_handler_foreman/foreman_resource_reporter.rb
+- lib/chef_handler_foreman/foreman_uploader.rb
+- lib/chef_handler_foreman/version.rb
+homepage: https://github.com/theforeman/chef-handler-foreman
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: This gem adds chef handlers so your chef-client can upload attributes (facts)
+  and reports to Foreman
+test_files: []
+has_rdoc: