foreman_dlm 0.1.0 → 2.0.0

data/app/models/foreman_dlm/dlmlock.rb

@@ -0,0 +1,137 @@
+module ForemanDlm
+  class Dlmlock < ApplicationRecord
+    include Authorizable
+
+    def self.humanize_class_name
+      N_('Distributed Lock')
+    end
+
+    def self.dlm_stale_time
+      (Setting[:dlm_stale_time] || 4).hours
+    end
+
+    belongs_to_host
+
+    has_many :dlmlock_events,
+             class_name: '::ForemanDlm::DlmlockEvent',
+             dependent: :destroy,
+             inverse_of: :dlmlock
+
+    validates :name, presence: true, uniqueness: true
+
+    after_save :log_enable_or_disable_event, if: -> { saved_change_to_enabled? }
+    after_save :log_release_and_acquire_events, if: -> { saved_change_to_host_id? }
+
+    def log_enable_or_disable_event
+      event_type = enabled ? :enable : :disable
+      log_event(host, event_type)
+    end
+
+    def log_release_and_acquire_events
+      old_host_id = saved_changes[:host_id].first
+      old_host = Host.find_by(id: old_host_id) if old_host_id
+      log_event(old_host, :release) if old_host
+      log_event(host, :acquire) if host
+    end
+
+    scope :locked,  -> { where.not(host_id: nil) }
+    scope :stale,   -> { locked.where('updated_at < ?', Time.now.utc - dlm_stale_time) }
+
+    scoped_search :on => :name, :complete_value => true, :default_order => true
+    scoped_search :relation => :host, :on => :name, :complete_value => true, :rename => :host
+    scoped_search :on => :type, :complete_value => true, :default_order => true
+    scoped_search :on => :enabled, :complete_value => { :true => true, :false => false }, :only_explicit => true
+
+    attr_accessor :old
+
+    def acquire!(host)
+      return false unless host.can_acquire_update_locks?
+
+      result = atomic_update(nil, host)
+      ForemanDlm::RefreshDlmlockStatus.set(wait: self.class.dlm_stale_time).perform_later([host.id]) if result
+      result
+    end
+
+    def release!(host)
+      atomic_update(host, nil)
+    end
+
+    def enable!
+      update(enabled: true)
+    end
+
+    def disable!
+      update(enabled: false)
+    end
+
+    def locked_by?(host)
+      self.host == host
+    end
+    alias acquired_by? locked_by?
+
+    def disabled?
+      !enabled?
+    end
+
+    def locked?
+      host.present?
+    end
+    alias taken? locked?
+
+    def humanized_type
+      _('Generic Lock')
+    end
+
+    private
+
+    def atomic_update(old_host, new_host)
+      changes = { host_id: new_host.try(:id) }
+      self.old = dup
+
+      query = {
+        id: id,
+        host_id: [new_host.try(:id), old_host.try(:id)],
+        enabled: true
+      }
+
+      updated = self.class.where(query).update(changes.merge(updated_at: Time.now.utc))
+
+      unless updated.count.zero?
+        reload
+        process_host_change(old_host, new_host)
+        [old_host, new_host].compact.each(&:refresh_dlmlock_status)
+        return true
+      end
+
+      log_event(host, :fail)
+
+      false
+    end
+
+    def process_host_change(old_host, new_host)
+      return if host.try(:id) == old.host.try(:id)
+
+      run_callback(old_host, :unlock) if old.host
+
+      return unless host
+
+      run_callback(new_host, :lock)
+    end
+
+    def log_event(host, event_type)
+      DlmlockEvent.create!(
+        dlmlock: self,
+        event_type: event_type,
+        host: host,
+        user: User.current
+      )
+    end
+
+    def run_callback(h, callback)
+      h.run_callbacks callback do
+        logger.debug { "custom hook after_#{callback} on #{h} will be executed if defined." }
+        true
+      end
+    end
+  end
+end

data/app/models/foreman_dlm/dlmlock_event.rb

@@ -0,0 +1,23 @@
+module ForemanDlm
+  class DlmlockEvent < ApplicationRecord
+    include Authorizable
+    include Expirable
+
+    TYPES = %w[release acquire enable disable fail].freeze
+    validates :event_type, inclusion: { in: TYPES }
+
+    def self.humanize_class_name
+      N_('Distributed Lock Event')
+    end
+
+    belongs_to_host
+    belongs_to :dlmlock, inverse_of: :dlmlock_events, class_name: 'ForemanDlm::Dlmlock'
+    belongs_to :user, inverse_of: :dlmlock_events
+
+    scoped_search on: :event_type, complete_value: true
+
+    def humanized_type
+      _('Dlmlock Event')
+    end
+  end
+end

data/app/models/host_status/dlmlock_status.rb

@@ -0,0 +1,44 @@
+module HostStatus
+  class DlmlockStatus < Status
+    OK = 0
+    STALE = 1
+
+    def self.status_name
+      N_('Distributed Lock')
+    end
+
+    def to_label(_options = {})
+      case to_status
+      when OK
+        N_('Ok')
+      when STALE
+        N_('Stale')
+      else
+        N_('Unknown')
+      end
+    end
+
+    def to_global(_options = {})
+      case to_status
+      when OK
+        HostStatus::Global::OK
+      else
+        HostStatus::Global::ERROR
+      end
+    end
+
+    def to_status(_options = {})
+      ok? ? OK : STALE
+    end
+
+    def relevant?(_options = {})
+      host.dlmlocks.any?
+    end
+
+    private
+
+    def ok?
+      host.dlmlocks.stale.empty?
+    end
+  end
+end

data/app/views/api/v2/dlmlock_events/index.json.rabl

@@ -0,0 +1,2 @@
+collection @events
+attributes :id, :event_type, :created_at, :updated_at

data/app/views/api/v2/dlmlocks/show.json.rabl

@@ -3,6 +3,6 @@ object @dlmlock
 extends 'api/v2/dlmlocks/main'
 
 child :host do
-  node(:name) { |host| host.name }
+  node(:name, &:name)
   node(:self) { |host| host == @detected_host } if @detected_host
 end

data/app/views/api/v2/errors/precondition_failed.json.rabl

@@ -1,4 +1,4 @@
-object resource = controller.get_resource
+object controller.get_resource
 
 attributes :id
 

data/app/views/foreman_dlm/api/v2/dlm_facets/base.json.rabl

@@ -0,0 +1 @@
+attributes :id, :last_checkin_at

data/app/views/foreman_dlm/api/v2/dlm_facets/base_with_root.json.rabl

@@ -0,0 +1,3 @@
+child :dlm_facet => :dlm_facet_attributes do |_dlm_facet|
+  extends 'foreman_dlm/api/v2/dlm_facets/base'
+end

data/app/views/foreman_dlm/api/v2/dlm_facets/show.json.rabl

@@ -0,0 +1,3 @@
+child :dlm_facet => :dlm_facet_attributes do
+  extends 'foreman_dlm/api/v2/dlm_facets/base'
+end

data/app/views/foreman_dlm/dlmlocks/_details.html.erb

@@ -0,0 +1,42 @@
+<% if authorizer.can?(:view_dlmlock_events) %>
+  <table class="<%= table_css_classes('table-fixed') %>">
+    <thead>
+      <tr>
+        <th><%= _("Host") %></th>
+        <th><%= _("User") %></th>
+        <th><%= _("Type") %></th>
+        <th><%= _("Timestamp") %></th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @dlmlock.dlmlock_events.includes(:user).reorder(created_at: :desc).each do |event| %>
+
+        <tr>
+          <td>
+            <% if event.host %>
+              <%= link_to_if_authorized(event.host.name, hash_for_host_path(:id => event.host)) %>
+            <% end %>
+          </td>
+
+          <td>
+            <% if event.user %>
+              <% if event.user.hidden? %>
+                <em><%= event.user.name %></em>
+              <% else %>
+                <%= link_to_if_authorized(event.user.name, hash_for_edit_user_path(event.user)) %>
+              <% end %>
+            <% end %>
+          </td>
+
+          <td>
+            <%= _(event.event_type.humanize) %>
+          </td>
+
+          <td>
+            <%= event.created_at %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>

data/app/views/{dlmlocks → foreman_dlm/dlmlocks}/_list.html.erb

@@ -5,6 +5,7 @@
       <th><%= sort :host, :as => _("Owner") %></th>
       <th><%= sort :type, :as => _("Type") %></th>
       <th><%= sort :enabled, :as => _("Enabled") %></th>
+      <th class="col-md-2"><%= _('Actions') %></th>
     </tr>
   </thead>
   <tbody>
@@ -12,7 +13,7 @@
       <tr class="<%= lock.enabled? ? '' : 'warning' %>">
         <td>
           <%= icon_text(dlmlock_status_icon_class(lock),
-                        link_to_if_authorized(lock.name, hash_for_dlmlock_path(:id => lock)),
+                        link_to_if_authorized(lock.name, hash_for_foreman_dlm_dlmlock_path(:id => lock)),
                         kind: 'fa',
                         class: "#{dlmlock_status_icon_color_class(lock)} fa-lg")
                       %>
@@ -38,6 +39,7 @@
             <%= icon_text('toggle-off', 'Disabled', {kind: 'fa', class: 'center fa-lg', title: _('Disabled')}) %>
           <% end %>
         </td>
+        <td><%= action_buttons(*dlmlock_actions(lock, authorizer)) %></td>
       </tr>
     <% end %>
   </tbody>

data/app/views/foreman_dlm/dlmlocks/index.html.erb

@@ -0,0 +1,2 @@
+<% title _('Distributed Locks') %>
+<%= render :partial => 'list' %>

data/app/views/foreman_dlm/dlmlocks/show.html.erb

@@ -0,0 +1,10 @@
+<% title @dlmlock.name %>
+<% breadcrumbs(
+  resource_url: api_dlmlocks_path
+) if respond_to?(:breadcrumbs) # Requires Foreman >= 1.18 %>
+
+<%= title_actions link_to(_('Back'), foreman_dlm_dlmlocks_path, :class => 'btn btn-default'),
+  ((link_to(_("Host details"), @dlmlock.host, :class => 'btn btn-default') if @dlmlock.host.present?))
+%>
+
+<%= render 'details' %>

data/app/views/{dlmlocks → foreman_dlm/dlmlocks}/welcome.html.erb

@@ -6,9 +6,9 @@
   <p>
   <%= _('You don\'t seem to have any locks.') %></br>
   <%= _('The distributed lock manager allows you to automatically schedule system updates across a cluster of hosts.') %>
-  <%= link_to _('Learn more about this in the documentation.'), 'https://github.com/timogoebel/foreman_dlm', :rel => "external" %>.
+  <%= link_to _('Learn more about this in the documentation.'), 'https://github.com/dm-drogeriemarkt/foreman_dlm', :rel => "external" %>.
   </p>
   <div class="blank-slate-pf-main-action">
-    <%= link_to _('Documentation'), 'https://github.com/timogoebel/foreman_dlm', :rel => 'external', :class => 'btn btn-primary btn-lg' %>
+    <%= link_to _('Documentation'), 'https://github.com/dm-drogeriemarkt/foreman_dlm', :rel => 'external', :class => 'btn btn-primary btn-lg' %>
   </div>
 </div>

data/app/views/hosts/_dlmlocks_tab.html.erb

@@ -0,0 +1,39 @@
+<% if @host.dlmlocks.any? %>
+  <%= alert class: 'alert-info',
+    header: '',
+    text: n_(
+      'This host holds one lock.',
+      'This host holds %s locks.',
+      @host.dlmlocks.count
+    ) % @host.dlmlocks.count
+  %>
+<% end %>
+
+<table class="<%= table_css_classes %>">
+  <thead>
+    <tr>
+      <th colspan="2"><%= _('Locks') %></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td class="text-nowrap"><%= _('Last check-in') %></td>
+      <td><%= @host.dlm_facet && @host.dlm_facet.last_checkin_at ? date_time_relative(@host.dlm_facet.last_checkin_at) : _('N/A') %></td>
+    </tr>
+    <tr>
+      <td><%= _('Holds Locks') %></td>
+      <td>
+        <% if @host.dlmlocks.any? %>
+          <% @host.dlmlocks.authorized(:view_dlmlocks).each do |lock| %>
+            <%= link_to_if_authorized(lock.name, hash_for_foreman_dlm_dlmlock_path(lock)) %>
+            <span class="label label-<%= lock.updated_at > 6.hours.ago ? 'info' : 'warning' %>">
+              <%= _('acquired') %> <%= date_time_relative_value(lock.updated_at) %>
+            </span>
+          <% end %>
+        <% else %>
+          <%= _('None') %>
+        <% end %>
+      </td>
+    </tr>
+  </tbody>
+</table>

data/config/routes.rb

@@ -1,24 +1,31 @@
 Rails.application.routes.draw do
   namespace :api, :defaults => { :format => 'json' } do
     scope '(:apiv)', :module => :v2,
-      :defaults => { :apiv => 'v2' },
-      :apiv => /v1|v2/,
-      :constraints => ApiConstraints.new(:version => 2, :default => true) do
-        constraints(id: /[^\/]+/) do
-          resources :dlmlocks, only: [:index, :show, :update, :destroy] do
-            get :lock, on: :member, action: :show, controller: 'dlmlocks'
-            put :lock, on: :member, action: :acquire, controller: 'dlmlocks'
-            delete :lock, on: :member, action: :release, controller: 'dlmlocks'
-          end
+                     :defaults => { :apiv => 'v2' },
+                     :apiv => /v1|v2/,
+                     :constraints => ApiConstraints.new(:version => 2, :default => true) do
+      constraints(id: /[^\/]+/) do
+        resources :dlmlocks, only: [:index, :show, :update, :destroy] do
+          resources :dlmlock_events, only: [:index]
+
+          get :lock, on: :member, action: :show, controller: 'dlmlocks'
+          put :lock, on: :member, action: :acquire, controller: 'dlmlocks'
+          delete :lock, on: :member, action: :release, controller: 'dlmlocks'
         end
-        resources :dlmlocks, only: [:create]
       end
+      resources :dlmlocks, only: [:create]
+    end
   end
 
-  scope '/foreman_dlm' do
-    resources :dlmlocks, only: [:index, :show] do
+  namespace :foreman_dlm do
+    resources :dlmlocks, only: [:index, :show, :destroy] do
       collection do
-        get 'auto_complete_search'
+        get :auto_complete_search
+      end
+      member do
+        put :enable
+        put :disable
+        put :release
       end
     end
   end

data/contrib/systemd/foreman-dlm-expire-events.service

@@ -0,0 +1,10 @@
+[Unit]
+Description=Clean up expired Foreman DLM events
+Documentation=https://github.com/dm-drogeriemarkt/foreman_dlm/blob/master/README.md
+Requires=network.target
+
+[Service]
+Type=oneshot
+EnvironmentFile=-/etc/sysconfig/foreman_dlm
+ExecStart=/sbin/foreman-rake dlmlocks:expire
+TimeoutSec=30m

data/contrib/systemd/foreman-dlm-expire-events.timer

@@ -0,0 +1,8 @@
+[Unit]
+Description=Run foreman-dlm-expire-events.service nightly
+
+[Timer]
+OnCalendar=*-*-* 02:00:00
+
+[Install]
+WantedBy=timers.target

data/db/migrate/20170824084100_add_dlmlock.foreman_dlm.rb

@@ -1,4 +1,4 @@
-class AddDlmlock < ActiveRecord::Migration
+class AddDlmlock < ActiveRecord::Migration[4.2]
   def change
     create_table :dlmlocks do |t|
       t.string :name, null: false, unique: true

data/db/migrate/20180627150003_rename_dlmlock_sti_models.rb

@@ -0,0 +1,9 @@
+class RenameDlmlockStiModels < ActiveRecord::Migration[5.1]
+  def up
+    execute "UPDATE dlmlocks set type='ForemanDlm::Dlmlock::Update' where type='Dlmlock::Update';"
+  end
+
+  def down
+    execute "UPDATE dlmlocks set type='Dlmlock::Update' where type='ForemanDlm::Dlmlock::Update';"
+  end
+end

data/db/migrate/20180704162345_add_dlmlock_events.rb

@@ -0,0 +1,11 @@
+class AddDlmlockEvents < ActiveRecord::Migration[5.1]
+  def change
+    create_table :dlmlock_events do |t|
+      t.integer :dlmlock_id, index: true, null: false
+      t.string :event_type, index: true
+      t.integer :host_id, index: true
+      t.integer :user_id
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20180711090022_add_hosts_fk_to_dlmlocks.rb

@@ -0,0 +1,5 @@
+class AddHostsFkToDlmlocks < ActiveRecord::Migration[5.1]
+  def change
+    add_foreign_key :dlmlocks, :hosts
+  end
+end

data/db/migrate/20180711111903_create_dlm_facets.foreman_dlm.rb

@@ -0,0 +1,10 @@
+class CreateDlmFacets < ActiveRecord::Migration[5.1]
+  def change
+    create_table :dlm_facets do |t|
+      t.references :host, null: false, foreign_key: true, index: true, unique: true
+      t.column :last_checkin_at, :datetime
+
+      t.timestamps null: false
+    end
+  end
+end

data/db/migrate/20180713113208_update_permissions_for_scoped_models.rb

@@ -0,0 +1,13 @@
+class UpdatePermissionsForScopedModels < ActiveRecord::Migration[5.1]
+  class FakePermission < ApplicationRecord
+    self.table_name = 'permissions'
+  end
+
+  def up
+    FakePermission.where(resource_type: 'Dlmlock').update_all(resource_type: 'ForemanDlm::Dlmlock')
+  end
+
+  def down
+    FakePermission.where(resource_type: 'ForemanDlm::Dlmlock').update_all(resource_type: 'Dlmlock')
+  end
+end

data/lib/foreman_dlm/engine.rb

@@ -4,6 +4,7 @@ module ForemanDlm
 
     config.autoload_paths += Dir["#{config.root}/app/controllers/concerns"]
     config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
+    config.autoload_paths += Dir["#{config.root}/app/jobs"]
 
     # Add any db migrations
     initializer 'foreman_dlm.load_app_instance_data' do |app|
@@ -14,63 +15,101 @@ module ForemanDlm
 
     initializer 'foreman_dlm.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :foreman_dlm do
-        requires_foreman '>= 1.15'
+        requires_foreman '>= 3.0'
 
         apipie_documented_controllers ["#{ForemanDlm::Engine.root}/app/controllers/api/v2/*.rb"]
 
+        settings do
+          category(:general) do
+            setting('dlm_stale_time',
+                    type: :integer,
+                    default: 4,
+                    description: N_('Number of hours after which locked Distributed Lock is stale'),
+                    full_name: N_('Distributed Lock stale time'),
+                    validate: { numericality: { greater_than: 0 } })
+          end
+        end
+
         # Add permissions
         security_block :foreman_dlm do
           permission :view_dlmlocks, {
-            :dlmlocks => [:index, :show, :auto_complete_search],
+            :'foreman_dlm/dlmlocks' => [:index, :show, :auto_complete_search],
             :'api/v2/dlmlocks' => [:index, :show]
-          }, :resource_type => 'Dlmlock'
+          }, :resource_type => 'ForemanDlm::Dlmlock'
 
           permission :create_dlmlocks, {
             :'api/v2/dlmlocks' => [:create]
-          }, :resource_type => 'Dlmlock'
+          }, :resource_type => 'ForemanDlm::Dlmlock'
 
           permission :edit_dlmlocks, {
+            :'foreman_dlm/dlmlocks' => [:release, :enable, :disable],
             :'api/v2/dlmlocks' => [:update, :acquire, :release]
-          }, :resource_type => 'Dlmlock'
+          }, :resource_type => 'ForemanDlm::Dlmlock'
 
           permission :destroy_dlmlocks, {
+            :'foreman_dlm/dlmlocks' => [:destroy],
             :'api/v2/dlmlocks' => [:destroy]
-          }, :resource_type => 'Dlmlock'
+          }, :resource_type => 'ForemanDlm::Dlmlock'
+
+          permission :view_dlmlock_events, {
+            :'api/v2/dlmlock_events' => [:index]
+          }, :resource_type => 'ForemanDlm::DlmlockEvent'
         end
 
         # Add a new role called 'Distributed Lock Manager' if it doesn't exist
-        role 'Distributed Lock Manager', [:view_dlmlocks, :create_dlmlocks, :edit_dlmlocks, :destroy_dlmlocks]
+        role 'Distributed Lock Manager', [:view_dlmlocks,
+                                          :create_dlmlocks,
+                                          :edit_dlmlocks,
+                                          :destroy_dlmlocks,
+                                          :view_dlmlock_events],
+             'Role granting full access permissions to distributed locks'
 
         # add menu entry
-        menu :top_menu, :distributed_locks,
-             url_hash: { controller: :'dlmlocks', action: :index },
+        menu :top_menu, :foreman_dlm_dlmlocks,
+             url_hash: { controller: :'foreman_dlm/dlmlocks', action: :index },
              caption: N_('Distributed Locks'),
              parent: :monitor_menu,
              after: :audits
+
+        # Dlm Facet
+        register_facet(ForemanDlm::DlmFacet, :dlm_facet) do
+          api_view list: 'foreman_dlm/api/v2/dlm_facets/base_with_root', single: 'foreman_dlm/api/v2/dlm_facets/show'
+        end
+
+        register_custom_status HostStatus::DlmlockStatus
+
+        # extend host show page
+        extend_page('hosts/show') do |context|
+          context.add_pagelet :main_tabs,
+                              :name => N_('Locks'),
+                              :partial => 'hosts/dlmlocks_tab',
+                              :onlyif => proc { |host| host.dlm_facet }
+        end
       end
     end
 
     # Include concerns in this config.to_prepare block
     config.to_prepare do
-      begin
-        Host::Managed.send(:include, ForemanDlm::HostExtensions)
+      Host::Managed.include ForemanDlm::HostExtensions
+      User.include ForemanDlm::UserExtensions
+      Host::Managed.include ForemanDlm::DlmFacetHostExtensions
 
-        if ForemanDlm.with_monitoring?
-          Host::Managed.send(:include, ForemanDlm::HostMonitoringExtensions)
-        end
-      rescue => e
-        Rails.logger.warn "ForemanDlm: skipping engine hook (#{e})"
-      end
+      Host::Managed.include ForemanDlm::HostMonitoringExtensions if ForemanDlm.with_monitoring?
+    rescue StandardError => e
+      Rails.logger.warn "ForemanDlm: skipping engine hook (#{e})"
     end
 
     initializer 'foreman_dlm.register_gettext', after: :load_config_initializers do |_app|
-      locale_dir = File.join(File.expand_path('../../..', __FILE__), 'locale')
+      locale_dir = File.join(File.expand_path('../..', __dir__), 'locale')
       locale_domain = 'foreman_dlm'
       Foreman::Gettext::Support.add_text_domain locale_domain, locale_dir
     end
   end
 
   def self.with_monitoring?
-    (ForemanMonitoring rescue false) ? true : false
+    ForemanMonitoring # rubocop:disable Lint/Void
+    true
+  rescue StandardError
+    false
   end
 end

data/lib/foreman_dlm/version.rb

@@ -1,3 +1,3 @@
 module ForemanDlm
-  VERSION = '0.1.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/tasks/dlmlock_events.rake

@@ -0,0 +1,19 @@
+desc <<-TASK_DESCRIPTION
+ Expire lock events automatically
+
+ Available conditions:
+   * days        => number of days to keep reports (defaults to 14)
+   * batch_size  => number of records deleted in single SQL transaction (defaults to 1k)
+   * sleep_time  => delay in seconds between batches (defaults to 0.2)
+
+TASK_DESCRIPTION
+
+namespace :dlmlocks do
+  task expire: :environment do
+    created_before = ENV['days'].to_i.days if ENV['days']
+    batch_size = ENV['batch_size'].to_i if ENV['batch_size']
+    sleep_time = ENV['sleep_time'].to_f if ENV['sleep_time']
+
+    ForemanDlm::DlmlockEvent.expire(created_before: created_before, batch_size: batch_size, sleep_time: sleep_time)
+  end
+end