foreman_dlm 0.1.0 → 2.0.0

data/app/models/dlmlock.rb

@@ -1,79 +0,0 @@
-class Dlmlock < ActiveRecord::Base
-  include Authorizable
-
-  def self.humanize_class_name
-    N_('Distributed Lock')
-  end
-
-  belongs_to_host
-  audited
-
-  validates :name, presence: true, uniqueness: true
-
-  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)
-    atomic_update(nil, host)
-  end
-
-  def release!(host)
-    atomic_update(host, nil)
-  end
-
-  def locked_by?(host)
-    self.host == host
-  end
-  alias_method :acquired_by?, :locked_by?
-
-  def disabled?
-    !enabled?
-  end
-
-  def locked?
-    host.present?
-  end
-  alias_method :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
-    num_updated = self.class.where(
-      id: id,
-      host_id: [new_host.try(:id), old_host.try(:id)],
-      enabled: true
-    ).update_all(changes.merge(updated_at: DateTime.now))
-    if num_updated > 0
-      reload
-      process_host_change(old_host, new_host, changes)
-      return self
-    end
-    false
-  end
-
-  def process_host_change(old_host, new_host, changes)
-    return if host.try(:id) == old.host.try(:id)
-    write_audit(action: 'update', audited_changes: changes)
-    run_callback(old_host, :unlock) if old.host
-    run_callback(new_host, :lock) if host
-  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

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

@@ -1,35 +0,0 @@
-<table class="<%= table_css_classes('table-fixed') %>">
-  <thead>
-    <tr>
-      <th><%= _("Owner") %></th>
-      <th><%= _("Initiator") %></th>
-      <th><%= _("Timestamp") %></th>
-      <th><%= _("Enabled") %></th>
-    </tr>
-  </thead>
-  <tbody>
-    <% @dlmlock.audits.includes(:user).reorder(created_at: :desc).each do |audit| %>
-      <% revision = audit.revision %>
-      <tr>
-        <td>
-          <% if revision.host.present? %>
-            <%= link_to_if_authorized(revision.host.name, hash_for_host_path(:id => revision.host)) %>
-          <% end %>
-        </td>
-        <td>
-          <% if audit.user.hidden? %>
-            <em><%= audit.user.name %></em>
-          <% else %>
-            <%= link_to_if_authorized(audit.user.name, hash_for_edit_user_path(audit.user)) %>
-          <% end %>
-        </td>
-        <td>
-          <%= audit.created_at %>
-        </td>
-        <td>
-          <%= revision.enabled? %>
-        </td>
-      </tr>
-    <% end %>
-  </tbody>
-</table>

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

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

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

@@ -1,7 +0,0 @@
-<% title "#{@dlmlock.name} "%>
-
-<%= title_actions link_to(_('Back'), :back, :class => 'btn btn-default'),
-  ((link_to(_("Host details"), @dlmlock.host, :class => 'btn btn-default') if @dlmlock.host.present?))
-%>
-
-<%= render 'details' %>

data/test/controllers/dlmlocks_test.rb

@@ -1,24 +0,0 @@
-require 'test_plugin_helper'
-
-class DlmlocksControllerTest < ActionController::TestCase
-  test '#index' do
-    FactoryBot.create(:dlmlock)
-    get :index, {}, set_session_user
-    assert_response :success
-    assert_not_nil assigns('dlmlocks')
-    assert_template 'index'
-  end
-
-  test '#index with no lock shows welcome page' do
-    get :index, {}, set_session_user
-    assert_response :success
-    assert_template 'welcome'
-  end
-
-  test '#show' do
-    dlmlock = FactoryBot.create(:dlmlock)
-    get :show, { :id => dlmlock.id }, set_session_user
-    assert_response :success
-    assert_template 'show'
-  end
-end

data/test/models/dlmlock_test.rb

@@ -1,201 +0,0 @@
-require 'test_plugin_helper'
-
-class DlmlockTest < ActiveSupport::TestCase
-  setup do
-    User.current = users(:admin)
-  end
-
-  subject { FactoryBot.create(:dlmlock) }
-  should validate_presence_of(:name)
-  should validate_uniqueness_of(:name)
-
-  let(:host1) { FactoryBot.create(:host, :managed) }
-  let(:host2) { FactoryBot.create(:host, :managed) }
-
-  class HostWithCallbacks < ::Host::Managed
-    attr_accessor :callbacks
-
-    def initialize(*attributes, &block)
-      super
-      @callbacks = []
-    end
-
-    after_lock :callback1
-    after_unlock :callback2
-
-    def callback1
-      Rails.logger.debug "callback1 executed for #{self} (#{self.class})"
-      callbacks << 'callback1'
-    end
-
-    def callback2
-      Rails.logger.debug "callback2 executed for #{self} (#{self.class})"
-      callbacks << 'callback2'
-    end
-  end
-
-  let(:host1_with_callbacks) { HostWithCallbacks.create(:name => 'test1.example.com') }
-  let(:host2_with_callbacks) { HostWithCallbacks.create(:name => 'test2.example.com') }
-
-  context 'a free and enabled DLM lock' do
-    let(:dlmlock) { FactoryBot.create(:dlmlock) }
-
-    test 'should be enabled and unlocked' do
-      assert_equal true, dlmlock.enabled?
-      assert_equal false, dlmlock.disabled?
-      assert_equal false, dlmlock.locked?
-      assert_equal false, dlmlock.taken?
-    end
-
-    test 'can be acquired' do
-      assert_nil dlmlock.host
-      assert dlmlock.acquire!(host1)
-      assert_equal host1, dlmlock.reload.host
-    end
-
-    test 'can be released' do
-      assert_nil dlmlock.host
-      assert dlmlock.release!(host1)
-      assert_nil dlmlock.reload.host
-    end
-
-    test 'records audit change on acquisition by owner' do
-      assert_difference "Audit.where(auditable_type: 'Dlmlock').count" do
-        assert dlmlock.acquire!(host1)
-      end
-      audit_record = dlmlock.audits.last
-      assert_equal 'update', audit_record.action
-      assert_equal({:host_id => host1.id}, audit_record.audited_changes)
-    end
-
-    test 'records no audit change on release' do
-      assert_no_difference "Audit.where(auditable_type: 'Dlmlock').count" do
-        assert dlmlock.release!(host1)
-      end
-    end
-
-    test 'triggers after_lock callback' do
-      host = HostWithCallbacks.new
-      host.name = 'test.example.com'
-      host.save
-      assert dlmlock.acquire!(host)
-      assert_equal ['callback1'], host.callbacks
-    end
-  end
-
-  context 'a free and disabled DLM lock' do
-    let(:dlmlock) { FactoryBot.create(:dlmlock, :enabled => false) }
-
-    test 'should be disabled and unlocked' do
-      assert_equal false, dlmlock.enabled?
-      assert_equal true, dlmlock.disabled?
-      assert_equal false, dlmlock.locked?
-      assert_equal false, dlmlock.taken?
-    end
-
-    test 'can not be acquired' do
-      assert_nil dlmlock.host
-      assert_equal false, dlmlock.acquire!(host1)
-      assert_nil dlmlock.reload.host
-    end
-
-    test 'can not be released' do
-      assert_nil dlmlock.host
-      assert_equal false, dlmlock.release!(host1)
-      assert_nil dlmlock.reload.host
-    end
-
-    test 'triggers no callbacks' do
-      host = HostWithCallbacks.new
-      host.name = 'test.example.com'
-      host.save
-      assert_equal false, dlmlock.release!(host)
-      assert_equal [], host.callbacks
-    end
-  end
-
-  context 'an acquired DLM lock' do
-   let(:dlmlock) { FactoryBot.create(:dlmlock, :host => host1) }
-
-    test 'should be enabled and locked' do
-      assert_equal true, dlmlock.enabled?
-      assert_equal false, dlmlock.disabled?
-      assert_equal true, dlmlock.locked?
-      assert_equal true, dlmlock.taken?
-      assert_equal true, dlmlock.locked_by?(host1)
-      assert_equal true, dlmlock.acquired_by?(host1)
-    end
-
-    test 'can be acquired by owner' do
-      assert_equal host1, dlmlock.host
-      assert dlmlock.acquire!(host1)
-      assert_equal host1, dlmlock.reload.host
-    end
-
-    test 'can not be acquired by other host' do
-      assert_equal host1, dlmlock.host
-      assert_equal false, dlmlock.acquire!(host2)
-      assert_equal host1, dlmlock.reload.host
-    end
-
-    test 'can be released by owner' do
-      assert_equal host1, dlmlock.host
-      assert dlmlock.release!(host1)
-      assert_nil dlmlock.reload.host
-    end
-
-    test 'can not be released by other host' do
-      assert_equal host1, dlmlock.host
-      assert_equal false, dlmlock.release!(host2)
-      assert_equal host1, dlmlock.reload.host
-    end
-
-    test 'records audit change on release by owner' do
-      assert_difference "Audit.where(auditable_type: 'Dlmlock').count" do
-        assert dlmlock.release!(host1)
-      end
-      audit_record = dlmlock.audits.last
-      assert_equal 'update', audit_record.action
-      assert_equal({:host_id => nil}, audit_record.audited_changes)
-    end
-
-    test 'records no audit change on acquisition by owner' do
-      assert_no_difference "Audit.where(auditable_type: 'Dlmlock').count" do
-        assert dlmlock.acquire!(host1)
-      end
-    end
-
-    test 'triggers after_unlock callback on release by owner' do
-      host = HostWithCallbacks.new
-      host.name = 'test.example.com'
-      host.save
-      dlmlock.host = host
-      dlmlock.save
-      assert dlmlock.release!(host)
-      assert_equal ['callback2'], host.callbacks
-    end
-
-    test 'triggers no callbacks on release attempt by other host' do
-      assert host1_with_callbacks
-      assert host2_with_callbacks
-      dlmlock.update(:host => host1_with_callbacks)
-      assert_equal false, dlmlock.release!(host2_with_callbacks)
-      assert_equal [], host1_with_callbacks.callbacks
-      assert_equal [], host2_with_callbacks.callbacks
-    end
-
-    test 'triggers no callbacks on acquiry attempt by owner' do
-      assert host1_with_callbacks
-      dlmlock.update(:host => host1_with_callbacks)
-      assert dlmlock.acquire!(host1_with_callbacks)
-      assert_equal [], host1_with_callbacks.callbacks
-    end
-  end
-
-  context 'scoped search' do
-    test 'can be searched by name' do
-      dlmlock = FactoryBot.create(:dlmlock)
-      assert_equal Dlmlock::Update.find(dlmlock.id), Dlmlock.search_for("name ~ #{dlmlock.name}").first
-    end
-  end
-end