foreman_abrt 0.0.1

data/README.md

@@ -0,0 +1,191 @@
+# ForemanAbrt
+
+This plugin allows your Foreman instance to receive bug reports generated on
+your hosts by [ABRT](https://github.com/abrt/abrt) (Automatic Bug Reporting
+Tool). These reports can be inspected and eventually forwarded to the ABRT
+server.
+
+## Overview
+
+1. Whenever a bug is caught by ABRT on the managed host, it is sent to the Smart
+   proxy instead of being sent directly to the ABRT server.
+2. The Smart proxy receives the report and stores it to the disk. Stored
+   reports are then sent to Foreman every 30 minutes (by means of cron job).
+   The proxy may optionally:
+   - Forward the report to an ABRT server immediately after being received.
+     Server's response is discarded.
+   - Aggregate stored reports prior to sending them to the Foreman. Only one
+     instance of set of similar reports from a host is sent, together with
+     number of the reports in the set.
+3. Foreman receives the aggregated report and stores it to the database. The
+   reports can be inspected and forwarded to the ABRT server. If the server
+   responds with additional information about the report, such as links to bug
+   trackers or suggested solutions, it is displayed alongside the report.
+
+```
+
+ +--------------+  ureport   +-------------+  aggregated ureports   +---------+
+ | Managed host | ---------> | Smart proxy | ---------------------> | Foreman |
+ +--------------+            +-------------+                        +---------+
+                                    :                                  :  ^
+                                    :                          ureport :  :
+                                    :                                  :  : server response
+                                    :                                  V  :
+                                    :          ureport            +-------------+
+                                    + - - - - - - - - - - - - - ->| ABRT server |
+                                                                  +-------------+
+
+```
+
+## Installation
+
+To be able to see ABRT bug reports in your Foreman instance, you need to
+install the plugin itself, install ABRT plugin for your smart proxies and
+configure your hosts to send the bug reports to their smart proxy.
+
+### Installing the Foreman plugin
+
+To install the Foreman plugin, follow the [plugin installation
+instructions](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin).
+
+### Setting up smart proxies
+
+You need smart-proxy version 1.6 or later (e.g. installed from git) in order to
+install the ABRT plugin.
+
+- If you want to use the report aggregation (reports are grouped on the proxy
+  and the same reports are sent only once), you have to install the satyr ruby
+  gem:
+
+  ```
+  ~# yum install satyr rubygem-ffi
+  ~# gem install satyr
+  ```
+
+- Install the ABRT smart-proxy plugin:
+
+  ```
+  ~$ git clone https://github.com/abrt/smart-proxy-abrt.git
+  ~$ cd smart-proxy-abrt
+  ~/smart-proxy-abrt$ gem build smart_proxy_abrt.gemspec
+  ~/smart-proxy-abrt$ yum install rubygems-devel rubygem-minitest
+  ~/smart-proxy-abrt$ rpmbuild --define "_sourcedir `pwd`" -ba extra/rubygem-smart_proxy_abrt.spec
+  ~/smart-proxy-abrt$ yum install ~/rpmbuild/RPMS/noarch/rubygem-smart_proxy_abrt*rpm
+  ```
+
+- Edit `/etc/foreman-proxy/settings.yml` to configure the main Foreman host,
+  which is normally not needed. Assuming Foreman runs on `f19-foreman.tld` the
+  file should contain following:
+
+  ```
+  # URL of your foreman instance
+  :foreman_url: https://f19-foreman.tld
+  ```
+
+- Rename `/etc/foreman-proxy/settings.d/abrt.yml.example` to `abrt.yml` to enable the ABRT proxy plugin:
+  ```
+  ~$ cd /etc/foreman-proxy/settings.d/
+  /etc/foreman-proxy/settings.d/$ mv abrt.yml.example abrt.yml
+  ```
+
+- Start the smart-proxy.
+
+  ```
+  ~# systemctl start foreman-proxy
+  ```
+
+### Configuring hosts to send bug reports to Foreman
+
+- Make sure that ABRT is installed and running.
+  ```
+  ~# yum install abrt-cli
+  ~# systemctl start abrtd
+  ~# systemctl start abrt-ccpp
+  ```
+
+- Configure ABRT reporting destination -
+  `/etc/libreport/plugins/ureport.conf` should contain following:
+
+  ```
+  # URL of your foreman-proxy, with /abrt path.
+  URL = https://f19-smartproxy.tld:8443/abrt
+  # Do not verify server certificate.
+  SSLVerify = no
+  # This asks puppet config for the path to the ceritificates. you can
+  # explicitly provide path by using /path/to/cert:/path/to/key on the
+  # right hand side.
+  SSLClientAuth = puppet
+  ```
+
+- Enable autoreporting by running the following command:
+
+  ```
+  ~# abrt-auto-reporting enabled
+  ```
+
+### Verifying that the setup works
+
+You can verify your setup by crashing something on your managed host. We have a
+set of utilities in the Fedora repository especially for this purpose:
+
+```
+~# yum -y install will-crash
+~$ will_segfault
+Will segfault.
+Segmentation fault (core dumped)
+```
+
+After a couple of seconds, a new file should appear in
+`/var/spool/foreman-proxy/abrt-send` on the smart-proxy host. The reports from
+the smart-proxy are sent to the Foreman in batches every half an hour (by
+default). This means that within half an hour you should be able to see the bug
+report in the Foreman web interface. You can send the reports to Foreman
+manually by running the `smart-proxy-abrt-send` command.
+
+## Usage
+
+The list of received bug reports can be accessed by clicking on *Bug reports*
+link in the *Monitor* menu. To see detailed information for a report, click on
+its reported date.
+
+List of bug reports coming from a particular host is also displayed on the page
+with the details about the host in the *Bug reports* tab on the left.
+
+### Forwarding the report to the ABRT server
+
+On the bug report details page you can forward the bug report to an actual
+ABRT server by clicking the *Forward report* button. The ABRT server may
+respond with some information it knows about the bug, such as the list of URLs
+related to the bug (e.g. Bugzilla link) and list of possible solutions to the
+problem that caused the bug to occur.
+
+The forwarding functionality may have to be configured in *Abrt* tab of the
+configuration screen (*Administer*->*Settings*).
+
+## TODO
+
+- Graph with number of reports vs. time on the dashboard.
+- Forwarding reports on the proxy - drop it altogether, or forward the server
+  response to the client?
+- Use puppet to configure managed hosts to send ureports to Foreman.
+- Figure out how to import the Puppet CA cert on managed hosts to the system
+  certificates so that the reporter-ureport doesn't have to skip server
+  certificate validation.
+
+## Copyright
+
+Copyright (c) 2014 Red Hat
+
+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/>.
+

data/Rakefile

@@ -0,0 +1,40 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanAbrt'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/abrt_reports.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/stylesheets/abrt_reports.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/abrt_reports_controller.rb

@@ -0,0 +1,62 @@
+class AbrtReportsController < ApplicationController
+  include Foreman::Controller::AutoCompleteSearch
+  before_filter :setup_search_options, :only => :index
+
+  def action_permission
+    case params[:action]
+      when 'json'
+        :view
+      when 'forward'
+        :forward
+      else
+        super
+    end
+  end
+
+  # GET /abrt_reports
+  def index
+    @abrt_reports = resource_base.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page], :per_page => params[:per_page]).includes(:host)
+  end
+
+  # GET /abrt_reports/42
+  def show
+    @abrt_report = resource_base.find(params[:id])
+  end
+
+  # DELETE /abrt_reports/42
+  def destroy
+    @abrt_report = resource_base.find(params[:id])
+    if @abrt_report.destroy
+      notice _("Successfully deleted bug report.")
+    else
+      error @abrt_reports.errors.full_messages.join("<br/>")
+    end
+    redirect_to abrt_reports_url
+  end
+
+  # GET /abrt_reports/42/json
+  def json
+    @abrt_report = resource_base.find(params[:id])
+    render :json => JSON.parse(@abrt_report.json)
+  end
+
+  # POST /abrt_reports/42/forward
+  def forward
+    @abrt_report = resource_base.find(params[:id])
+    redirect_to abrt_report_url(@abrt_report)
+
+    begin
+      response = @abrt_report.forward
+    rescue => e
+      error _("Server rejected our report: #{e.message}") and return
+    end
+
+    begin
+      @abrt_report.add_response response
+    rescue => e
+      error _("Cannot process server response: #{e.message}") and return
+    end
+
+    notice _("Report successfully forwarded")
+  end
+end

data/app/controllers/api/v2/abrt_reports_controller.rb

@@ -0,0 +1,37 @@
+module Api
+  module V2
+    class AbrtReportsController < V2::BaseController
+      include Api::Version2
+      include Foreman::Controller::SmartProxyAuth
+
+      add_puppetmaster_filters :create
+
+      def create
+        begin
+          abrt_reports = AbrtReport.import(params[:abrt_report])
+        rescue => e
+          logger.error "Failed to import ABRT report: #{e.message}"
+          logger.debug e.backtrace.join("\n")
+          render :json => { "message" => e.message }, :status => :unprocessable_entity
+          return
+        end
+
+        if Setting[:abrt_automatically_forward]
+          abrt_reports.each do |report|
+            begin
+              response = report.forward
+              report.add_response response
+            rescue => e
+              logger.error "Failed to forward ABRT report: #{e.message}"
+            end
+          end
+        end
+
+        # Do not report forwarding error to the proxy, we can manually resend
+        # it later and the proxy probably can't do anything about it anyway.
+        render :json => { "message" => "OK" }
+      end
+
+    end
+  end
+end

data/app/helpers/abrt_reports_helper.rb

@@ -0,0 +1,9 @@
+module AbrtReportsHelper
+  def simple_format_if_multiline str
+    if str.include? "\n"
+      simple_format str
+    else
+      str
+    end
+  end
+end

data/app/models/abrt_report.rb

@@ -0,0 +1,120 @@
+class AbrtReport < ActiveRecord::Base
+  include Authorizable
+
+  audited :associated_with => :host, :allow_mass_assignment => true
+
+  belongs_to_host
+  has_one :environment, :through => :host
+  has_one :hostgroup, :through => :host
+
+  has_many :abrt_report_response_destinations, :dependent => :destroy
+  has_many :abrt_report_response_solutions, :dependent => :destroy
+
+  validates :json, :presence => true
+  validates :count, :numericality => { :only_integer => true, :greater_than => 0 }
+  validates :duphash, :format => { :with => /\A[0-9a-fA-F]+\z/ }, :allow_blank => true
+
+  scoped_search :in => :host,        :on => :name,  :complete_value => true, :rename => :host
+  scoped_search :in => :environment, :on => :name,  :complete_value => true, :rename => :environment
+  scoped_search :in => :hostgroup,   :on => :name,  :complete_value => true, :rename => :hostgroup
+  scoped_search :in => :hostgroup,   :on => :title, :complete_value => true, :rename => :hostgroup_fullname
+  scoped_search :in => :hostgroup,   :on => :title, :complete_value => true, :rename => :hostgroup_title
+
+  scoped_search :on => :reason,       :complete_value => true
+  scoped_search :on => :duphash,      :complete_value => true
+  scoped_search :on => :count,        :complete_value => true, :only_explicit => true
+  scoped_search :on => :reported_at,  :complete_value => true, :default_order => :desc, :rename => :reported, :only_explicit => true
+
+  scoped_search :on => :forwarded_at,     :complete_value => true, :rename => :forwarded, :only_explicit => true
+  scoped_search :on => :response_known,   :complete_value => true, :rename => :known,     :only_explicit => true
+  scoped_search :on => :response_message, :complete_value => true, :rename => :response
+  scoped_search :on => :response_bthash,  :complete_value => true, :rename => :bthash
+
+  scoped_search :in => :abrt_report_response_destination, :on => :reporter, :complete_value => true, :rename => :destination_reporter
+  scoped_search :in => :abrt_report_response_destination, :on => :desttype, :complete_value => true, :rename => :destination_type
+  scoped_search :in => :abrt_report_response_destination, :on => :value   , :complete_value => true, :rename => :destination_value
+
+  scoped_search :in => :abrt_report_response_solution, :on => :cause, :complete_value => true, :rename => :solution_cause
+  scoped_search :in => :abrt_report_response_solution, :on => :note,  :complete_value => true, :rename => :solution_note
+  scoped_search :in => :abrt_report_response_solution, :on => :url,   :complete_value => true, :rename => :solution_url
+
+  def self.import(json)
+    host = Host.find_by_name(json[:host])
+    reports = []
+    AbrtReport.transaction do
+      json[:reports].each do |report|
+        # import one report
+        reason = nil # try extracting reason from the report
+        reason ||= report[:full][:reason] if report[:full].has_key? :reason
+        reports << AbrtReport.create!(:host => host, :count => report[:count], :json => report[:full].to_json,
+                                      :duphash => report[:duphash], :reason => reason,
+                                      :reported_at => report[:reported_at])
+      end
+    end
+    reports
+  end
+
+  # XXX is the network communication acceptable in a model?
+  def forward
+    request_params = {
+      :timeout => 60,
+      :open_timeout => 10,
+      :verify_ssl => Setting[:abrt_server_verify_ssl] ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+    }
+
+    if Setting[:abrt_server_ssl_ca_file] && !Setting[:abrt_server_ssl_ca_file].empty?
+      request_params[:ssl_ca_file] = Setting[:abrt_server_ssl_ca_file]
+    end
+
+    # XXX what certificates will be used if communicating with e.g. customer portal?
+    if Setting[:abrt_server_ssl_certificate] && !Setting[:abrt_server_ssl_certificate].empty? \
+       && Setting[:abrt_server_ssl_priv_key] && !Setting[:abrt_server_ssl_priv_key].empty?
+      request_params[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(Setting[:abrt_server_ssl_certificate]))
+      request_params[:ssl_client_key]  = OpenSSL::PKey::RSA.new(File.read(Setting[:abrt_server_ssl_priv_key]))
+    end
+
+    resource = RestClient::Resource.new(Setting[:abrt_server_url], request_params)
+    response = resource['reports/new/'].post({:file => json, :multipart => true}, :content_type => :json, :accept => :json)
+
+    if response.code != 202
+      logger.error "Failed to forward bug report: #{response.code}: #{response.to_str}"
+      raise ::Foreman::Exception.new(N_("Failed to forward bug report: %s: %s", response.code, response.to_str))
+    end
+
+    JSON.parse(response.body)
+  end
+
+  def add_response(response)
+    self.transaction do
+      abrt_report_response_solutions.clear
+      abrt_report_response_destinations.clear
+
+      self.forwarded_at = Time.now
+      self.response_known = response['result']
+      self.response_message = response['message']
+      self.response_bthash = response['bthash']
+
+      if response['solutions']
+        response['solutions'].each do |solution|
+          abrt_report_response_solutions.create!(
+            :cause => solution['cause'],
+            :note => solution['note'],
+            :url => solution['url']
+          )
+        end
+      end
+
+      if response['reported_to']
+        response['reported_to'].each do |destination|
+          abrt_report_response_destinations.create!(
+            :desttype => destination['type'],
+            :value => destination['value'],
+            :reporter => destination['reporter']
+          )
+        end
+      end
+
+      save!
+    end
+  end
+end