foreman_webhooks 0.0.1

data/README.md

@@ -0,0 +1,30 @@
+# ForemanWebhooks
+
+Don't call us, we'll call you. This plugins allows to configure Webhooks for Foreman.
+
+## Installation
+
+See [How_to_Install_a_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin)
+for how to install Foreman plugins
+
+## Contributing
+
+Fork and send a Pull Request. Thanks!
+
+## Copyright
+
+Copyright (c) 2019 Timo Goebel
+
+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,49 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+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    = 'ForemanWebhooks'
+  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', __dir__)
+
+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
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue StandardError => _e
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Api
+  module V2
+    class WebhookTemplatesController < V2::BaseController
+      include Api::Version2
+      include ForemanWebhooks::Controller::Parameters::WebhookTemplate
+      include Foreman::Controller::TemplateImport
+
+      before_action :find_resource, only: %i[show update destroy clone export]
+
+      api :GET, '/webhook_templates/', N_('List webhook templates')
+      param_group :search_and_pagination, ::Api::V2::BaseController
+      add_scoped_search_description_for(WebhookTemplate)
+      def index
+        @webhook_templates = resource_scope_for_index
+      end
+
+      api :GET, '/webhook_templates/:id', N_('Show webhook template details')
+      param :id, :identifier, required: true
+      def show; end
+
+      def_param_group :webhook_template do
+        param :webhook_template, Hash, action_aware: true, required: true do
+          param :name, String, required: true
+          param :description, String
+          param :template, String, required: true
+          param :snippet, :bool, allow_nil: true
+          param :audit_comment, String, allow_nil: true
+          param :locked, :bool, desc: N_('Whether or not the template is locked for editing')
+          param :default, :bool, desc: N_('Whether or not the template is added automatically to new organizations and locations')
+          param_group :taxonomies, ::Api::V2::BaseController
+        end
+      end
+
+      def_param_group :webhook_template_clone do
+        param :webhook_template, Hash, required: true, action_aware: true do
+          param :name, String, required: true, desc: N_('Template name')
+        end
+      end
+
+      api :POST, '/webhook_templates/', N_('Create a webhook template')
+      param_group :webhook_template, as: :create
+      def create
+        @webhook_template = WebhookTemplate.new(webhook_template_params)
+        process_response @webhook_template.save
+      end
+
+      api :POST, '/webhook_templates/import', N_('Import a webhook template')
+      param :webhook_template, Hash, required: true, action_aware: true do
+        param :name, String, required: true, desc: N_('Template name')
+        param :template, String, required: true, desc: N_('Template contents including metadata')
+        param_group :taxonomies, ::Api::V2::BaseController
+      end
+      param_group :template_import_options, ::Api::V2::BaseController
+      def import
+        @webhook_template = WebhookTemplate.import!(*import_attrs_for(:webhook_template))
+        process_response @webhook_template
+      end
+
+      api :PUT, '/webhook_templates/:id', N_('Update a webhook template')
+      param :id, :identifier, required: true
+      param_group :webhook_template, as: :update
+      def update
+        process_response @webhook_template.update(webhook_template_params)
+      end
+
+      api :DELETE, '/webhook_templates/:id', N_('Delete a webhook template')
+      param :id, :identifier, required: true
+      def destroy
+        process_response @webhook_template.destroy
+      end
+
+      api :POST, '/webhook_templates/:id/clone', N_('Clone a template')
+      param :id, :identifier, required: true
+      param_group :webhook_template_clone, as: :create
+      def clone
+        @webhook_template = @webhook_template.dup
+        @webhook_template.name = params[:webhook_template][:name]
+        process_response @webhook_template.save
+      end
+
+      api :GET, '/webhook_templates/:id/export', N_('Export a webhook template to ERB')
+      param :id, :identifier, required: true
+      def export
+        send_data @webhook_template.to_erb, type: 'text/plain',
+                                            disposition: 'attachment',
+                                            filename: @webhook_template.filename
+      end
+
+      private
+
+      # Overload this method to avoid using search_for method
+      def resource_scope_for_index(options = {})
+        resource_scope(options).paginate(paginate_options)
+      end
+
+      def action_permission
+        case params[:action]
+        when 'clone', 'import'
+          'create'
+        when 'export'
+          'view'
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Api
+  module V2
+    class WebhooksController < V2::BaseController
+      include Api::Version2
+      include ForemanWebhooks::Controller::Parameters::Webhook
+      include Foreman::Controller::TemplateImport
+
+      before_action :find_resource, only: %i[show update destroy]
+
+      api :GET, '/webhooks/', N_('List Webhooks')
+      param_group :search_and_pagination, ::Api::V2::BaseController
+      def index
+        @webhooks = resource_scope_for_index
+      end
+
+      api :GET, '/webhooks/:id', N_('Show Webhook details')
+      param :id, :identifier, required: true
+      def show; end
+
+      def_param_group :webhook do
+        param :webhook, Hash, action_aware: true, required: true do
+          param :name, String, required: true
+          param :target_url, String, required: true
+          param :http_method, Webhook::ALLOWED_HTTP_METHODS
+          param :http_content_type, String
+          param :event, String, required: true
+          param :webhook_template_id, :identifier
+          param :enabled, :boolean
+          param :verify_ssl, :boolean
+          param :ssl_ca_certs, String, N_('X509 Certification Authorities concatenated in PEM format')
+          param :user, String
+          param :password, String
+          param :http_headers, String
+        end
+      end
+
+      api :POST, '/webhooks/', N_('Create a Webhook')
+      param_group :webhook, as: :create
+
+      def create
+        @webhook = Webhook.new(webhook_params)
+        process_response @webhook.save
+      end
+
+      api :PUT, '/webhooks/:id', N_('Update a Webhook')
+      param :id, :identifier, required: true
+      param_group :webhook, as: :update
+      def update
+        process_response @webhook.update(webhook_params)
+      end
+
+      api :DELETE, '/webhooks/:id', N_('Delete a Webhook')
+      param :id, :identifier, required: true
+      def destroy
+        process_response @webhook.destroy
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_webhooks/controller/parameters/webhook.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ForemanWebhooks
+  module Controller
+    module Parameters
+      module Webhook
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def webhook_params_filter
+            Foreman::ParameterFilter.new(::Webhook).tap do |filter|
+              filter.permit :name,
+                            :target_url,
+                            :webhook_template_id,
+                            :event,
+                            :http_method,
+                            :http_content_type,
+                            :enabled,
+                            :verify_ssl,
+                            :ssl_ca_certs,
+                            :user,
+                            :password,
+                            :http_headers
+            end
+          end
+        end
+
+        def webhook_params
+          self.class.webhook_params_filter.filter_params(params, parameter_filter_context)
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_webhooks/controller/parameters/webhook_template.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ForemanWebhooks
+  module Controller
+    module Parameters
+      module WebhookTemplate
+        extend ActiveSupport::Concern
+        include Foreman::Controller::Parameters::Taxonomix
+        include Foreman::Controller::Parameters::Template
+
+        class_methods do
+          def webhook_template_params_filter
+            Foreman::ParameterFilter.new(::WebhookTemplate).tap do |filter|
+              add_taxonomix_params_filter(filter)
+              add_template_params_filter(filter)
+            end
+          end
+        end
+
+        def webhook_template_params
+          self.class.webhook_template_params_filter.filter_params(params, parameter_filter_context)
+        end
+
+        def organization_params
+          self.class.organization_params_filter(::WebhookTemplate).filter_params(params, parameter_filter_context)
+        end
+
+        def location_params
+          self.class.location_params_filter(::WebhookTemplate).filter_params(params, parameter_filter_context)
+        end
+      end
+    end
+  end
+end

data/app/controllers/webhook_templates_controller.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class WebhookTemplatesController < TemplatesController
+  include ForemanWebhooks::Controller::Parameters::WebhookTemplate
+end

data/app/controllers/webhooks_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class WebhooksController < ::ApplicationController
+  include ForemanWebhooks::Controller::Parameters::Webhook
+  include Foreman::Controller::AutoCompleteSearch
+
+  before_action :find_resource, only: %i[edit update destroy]
+
+  def new
+    @webhook = Webhook.new
+  end
+
+  def create
+    @webhook = Webhook.new(webhook_params)
+    if @webhook.save
+      process_success success_redirect: '/webhooks'
+    else
+      process_error
+    end
+  end
+
+  def edit; end
+
+  def update
+    if @webhook.update(webhook_params)
+      process_success success_redirect: '/webhooks'
+    else
+      process_error
+    end
+  end
+
+  def destroy
+    if @webhook.destroy
+      process_success
+    else
+      process_error
+    end
+  end
+end

data/app/jobs/foreman_webhooks/deliver_webhook_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ForemanWebhooks
+  class DeliverWebhookJob < ::ApplicationJob
+    queue_as :default
+
+    def perform(options)
+      webhook = Webhook.unscoped.find_by(id: options[:webhook_id])
+      WebhookService.new(
+        webhook: webhook,
+        headers: options[:headers],
+        url: options[:url],
+        event_name: options[:event_name],
+        payload: options[:payload]
+      ).execute
+    end
+
+    def webhook_id
+      arguments.first['webhook_id'] unless arguments.first.nil?
+    end
+
+    def humanized_name
+      webhook = webhook_id && Webhook.unscoped.find_by(id: webhook_id)
+      (webhook && (_('Deliver webhook %s') % webhook.name)) || _('Deliver webhook')
+    end
+  end
+end

data/app/lib/foreman_webhooks/renderer/scope/webhook_template.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ForemanWebhooks
+  module Renderer
+    module Scope
+      class WebhookTemplate < ::Foreman::Renderer::Scope::Template
+        extend ApipieDSL::Class
+
+        apipie :class, 'Macros related to Webhook payload customization' do
+          name 'Webhook Template'
+          sections only: %w[all webhooks]
+        end
+
+        def initialize(**args)
+          super
+          @defaults = {
+            event_name: @event_name,
+            webhook_id: @webhook_id,
+            context: @context
+          }
+        end
+
+        apipie :method, 'Creates final payload' do
+          required :hash, Hash, 'Key=value object with with data that should be present in payload'
+          keyword :with_defaults, [true, false], 'If set to true, adds default entries to the payload', default: true
+          returns String, 'JSON string with the final payload'
+          example 'payload({ id: @object.id, name: @object.name }) #=> "{ "id": 1, "name": "host.example.com", "context": { ... }, "event_name": "host_created.event.foreman" }"'
+        end
+        def payload(hash, with_defaults: true)
+          hash.merge!(@defaults) if with_defaults
+          hash.to_json
+        end
+      end
+    end
+  end
+end

data/app/models/webhook.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+class Webhook < ApplicationRecord
+  audited
+  include Authorizable
+  include Encryptable
+
+  extend FriendlyId
+  friendly_id :name
+  include Parameterizable::ByIdName
+
+  EVENT_POSTFIX = ".#{Foreman::Observable::DEFAULT_NAMESPACE}"
+
+  EVENT_ALLOWLIST = %w[
+    host_created host_updated host_destroyed
+    hostgroup_created hostgroup_updated hostgroup_destroyed
+    user_created user_updated user_destroyed
+    domain_created domain_updated domain_destroyed
+    subnet_created subnet_updated subnet_destroyed
+    build_entered build_exited status_changed
+  ].map { |e| e + EVENT_POSTFIX }.freeze
+
+  DEFAULT_PAYLOAD_TEMPLATE = 'Webhook Template - Payload Default'
+
+  ALLOWED_HTTP_METHODS = %w[POST GET PUT DELETE PATCH].freeze
+
+  encrypts :password
+
+  attribute :events, :string, array: true, default: []
+
+  validates_lengths_from_database
+  validates :name, :target_url, :events, presence: true
+  validates :target_url, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https]),
+                                   message: _('URL must be valid and schema must be one of: %s') % 'http, https' }
+  validates :http_method, inclusion: { in: ALLOWED_HTTP_METHODS }
+
+  belongs_to :webhook_template, foreign_key: :webhook_template_id
+
+  before_save :set_default_template, unless: :webhook_template
+
+  scope :for_event, ->(events) { where('events @> ARRAY[?]::varchar[]', Array(events)) }
+
+  default_scope -> { order('webhooks.name') }
+
+  scoped_search on: :name, complete_value: true, default_order: true
+  scoped_search on: :target_url, complete_value: :true
+  scoped_search on: :enabled, complete_value: { true: true, false: false }
+
+  def self.available_events
+    ::Foreman::EventSubscribers.all_observable_events & EVENT_ALLOWLIST
+  end
+
+  def self.deliver(event_name:, payload:)
+    for_event(event_name).includes([:webhook_template]).each do |target|
+      target.deliver(event_name: event_name, payload: payload) if target.enabled?
+    end
+  end
+
+  def events=(events)
+    events = Array(events).map do |event|
+      next event if event.end_with?(EVENT_POSTFIX)
+
+      event.to_s.underscore + EVENT_POSTFIX
+    end
+    super(self.class.available_events & events)
+  end
+
+  def event=(event)
+    self.events = event
+  end
+
+  def event
+    events.first
+  end
+
+  def deliver(event_name:, payload:)
+    payload_to_deliver = rendered_payload(event_name, payload)
+    headers_to_deliver = rendered_headers(event_name, payload)
+    url_to_deliver = rendered_targed_url(event_name, payload)
+    ::ForemanWebhooks::DeliverWebhookJob.perform_later(
+      event_name: event_name,
+      payload: payload_to_deliver,
+      headers: headers_to_deliver,
+      url: url_to_deliver,
+      webhook_id: id
+    )
+  end
+
+  def ca_certs_store
+    store = OpenSSL::X509::Store.new
+    return store if ssl_ca_certs.blank?
+
+    ssl_ca_certs.split(/(?=-----BEGIN)/).each do |cert|
+      store.add_cert(OpenSSL::X509::Certificate.new(cert))
+    end
+    store
+  rescue StandardError => e
+    raise _(format('Failed to build X509 certificate store for HTTPS client, error: %s', e.message))
+  end
+
+  private
+
+  def set_default_template
+    self.webhook_template = WebhookTemplate.find_by!(name: DEFAULT_PAYLOAD_TEMPLATE)
+  end
+
+  def variables(event_name, payload)
+    {
+      event_name: event_name,
+      object: payload[:object],
+      context: payload[:context],
+      payload: payload,
+      webhook_id: id
+    }
+  end
+
+  def render_source(source, event_name, payload)
+    scope = Foreman::Renderer.get_scope(
+      klass: ForemanWebhooks::Renderer::Scope::WebhookTemplate,
+      variables: variables(event_name, payload),
+      source: source
+    )
+    Foreman::Renderer.render(source, scope)
+  end
+
+  def rendered_payload(event_name, payload)
+    webhook_template.render(variables: variables(event_name, payload))
+  end
+
+  def rendered_headers(event_name, payload)
+    return nil if http_headers.empty?
+
+    source = Foreman::Renderer::Source::String.new(name: 'HTTP header template', content: http_headers)
+    render_source(source, event_name, payload)
+  end
+
+  def rendered_targed_url(event_name, payload)
+    source = Foreman::Renderer::Source::String.new(name: 'HTTP target URL template', content: target_url)
+    render_source(source, event_name, payload)
+  end
+end