Add --clowntown-disable-locking-mechanism flag

Summary:
Add a CLI flag that makes acquire_lock and release_lock no-ops,
for use in antlir-builds where concurrent runs are not a concern.

Reviewed By: vmagro

Differential Revision: D93008263

fbshipit-source-id: 517d0e328553db9d32a5561284d62a877bfe4d1f

Author: dafyddcrosby

chefctl/src/chefctl.rb

@@ -221,6 +221,9 @@ module Config
     # Windows values are as follows: "Idle" => 64, "BelowNormal" => 16384,
     # "Normal" => 32, "AboveNormal" => 32768, "High" => 128, "Realtime" => 256
     priority nil
+
+    # When true, acquire_lock and release_lock become no-ops.
+    disable_locking false
   end
 
   # Chefctl plugins are used to define custom behavior for chefctl.
@@ -825,6 +828,11 @@ def keep_testing
 
     # Acquire the lock
     def acquire_lock
+      if Chefctl::Config.disable_locking
+        Chefctl.logger.warn('Locking is disabled via --clowntown-disable-locking-mechanism')
+        return
+      end
+
       if Chefctl::Config.immediate
         Chefctl.lib.stop_or_wait_for_chef(@paths[:chef_cur])
       end
@@ -862,6 +870,8 @@ def acquire_lock
 
     # Release the lock, if it's being held.
     def release_lock
+      return if Chefctl::Config.disable_locking
+
       if @lock[:fd]
         if @lock[:held]
           @lock[:fd].flock(File::LOCK_UN)
@@ -1354,6 +1364,15 @@ def parse_both_passes(argv = nil)
       Chefctl.program_name = v
     end
 
+    parser.on(
+      '--clowntown-disable-locking-mechanism',
+      'Disable the locking mechanism so acquire_lock and release_lock are no-ops. ' +
+      'This should only be used in situations (ie build system one-off jobs) where ' +
+      'there is certainty that chefctl will only be called once.',
+    ) do
+      options[:disable_locking] = true
+    end
+
     parser.
       on(
         '--priority PRIORITY',

chefctl/src/spec/chefctl_spec.rb

@@ -197,6 +197,42 @@ def lib
   end
 end
 
+RSpec.describe Chefctl::Main, 'locking with disable_locking' do
+  let(:main) { Chefctl::Main.new('/var/chef/outputs', 'foo') }
+
+  around do |example|
+    original = Chefctl::Config.disable_locking
+    Chefctl::Config.disable_locking true
+    example.run
+  ensure
+    Chefctl::Config.disable_locking original
+  end
+
+  it 'acquire_lock is a no-op when disable_locking is true' do
+    expect(main).not_to receive(:wait_for_lock)
+    main.acquire_lock
+  end
+
+  it 'release_lock is a no-op when disable_locking is true' do
+    lock_fd = double('lock_fd')
+    main.instance_variable_get(:@lock)[:fd] = lock_fd
+    main.instance_variable_get(:@lock)[:held] = true
+    expect(lock_fd).not_to receive(:flock)
+    expect(lock_fd).not_to receive(:close)
+    expect(File).not_to receive(:unlink)
+    main.release_lock
+  end
+
+  it 'lock still yields the block when locking is disabled' do
+    # Stub to prevent filesystem access if disable_locking guard fails
+    allow(File).to receive(:open).with('/var/lock/subsys/chefctl', anything).
+      and_raise('locking should be disabled')
+    yielded = false
+    main.lock { yielded = true }
+    expect(yielded).to eq(true)
+  end
+end
+
 RSpec.describe TwoPassParser do
   it 'should perform two passes' do
     n = 0