Add LockRunner class for acquiring a lock from the Locket service.

- Generated GRPC service for Locket, based on https://github.com/cloudfoundry/locket/blob/master/models/locket.proto
- Mimic Locket's own "LockRunner" default behavior

[#158367668]

Signed-off-by: Tim Downey <[email protected]>

Author: selzoc

lib/locket/lock_runner.rb

@@ -0,0 +1,68 @@
+require 'locket/locket_services_pb'
+
+module Locket
+  class LockRunner
+    class Error < StandardError
+    end
+
+    def initialize(host:, port:, client_ca_path:, client_cert_path:, client_key_path:)
+      client_ca = File.open(client_ca_path).read
+      client_key = File.open(client_key_path).read
+      client_cert = File.open(client_cert_path).read
+
+      @service = Models::Locket::Stub.new(
+        "#{host}:#{port}",
+        GRPC::Core::ChannelCredentials.new(client_ca, client_key, client_cert)
+      )
+      @lock_acquired = false
+    end
+
+    def start(key, owner)
+      raise Error.new('Cannot start more than once') if @thread
+
+      @thread = Thread.new do
+        loop do
+          begin
+            service.lock(build_lock_request(key, owner))
+            logger.debug("Acquired lock '#{key}' for owner '#{owner}'")
+            @lock_acquired = true
+          rescue GRPC::BadStatus => e
+            logger.debug("Failed to acquire lock '#{key}' for owner '#{owner}': #{e.message}")
+            @lock_acquired = false
+          end
+
+          sleep 1
+        end
+      end
+    end
+
+    def stop
+      @thread.kill if @thread
+    end
+
+    def lock_acquired?
+      lock_acquired
+    end
+
+    private
+
+    attr_reader :service, :lock_acquired
+
+    def build_lock_request(key, owner)
+      Models::LockRequest.new(
+        {
+          resource: {
+            key: key,
+            owner: owner,
+            type_code: Models::TypeCode::LOCK,
+          },
+          ttl_in_seconds: 15,
+        }
+      )
+    end
+
+    def logger
+      @logger ||= Steno.logger('cc.locket-client')
+    end
+  end
+end

lib/locket/locket_pb.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'locket/lock_runner'
+
+RSpec.describe Locket::LockRunner do
+  let(:locket_service) { instance_double(Models::Locket::Stub) }
+  let(:key) { 'lock-key' }
+  let(:owner) { 'lock-owner' }
+  let(:host) { 'locket.capi.land' }
+  let(:port) { '1234' }
+  let(:client_ca_path) { File.join(Paths::FIXTURES, 'certs/bbs_ca.crt') }
+  let(:client_cert_path) { File.join(Paths::FIXTURES, 'certs/bbs_client.crt') }
+  let(:client_key_path) { File.join(Paths::FIXTURES, 'certs/bbs_client.key') }
+  let(:credentials) { instance_double(GRPC::Core::ChannelCredentials) }
+  let(:lock_request) do
+    Models::LockRequest.new(
+      {
+        resource: { key: key, owner: owner, type_code: Models::TypeCode::LOCK },
+        ttl_in_seconds: 15
+      }
+    )
+  end
+
+  let(:client) do
+    Locket::LockRunner.new(
+      host: host,
+      port: port,
+      client_ca_path: client_ca_path,
+      client_key_path: client_key_path,
+      client_cert_path: client_cert_path,
+    )
+  end
+
+  before do
+    client_ca = File.open(client_ca_path).read
+    client_key = File.open(client_key_path).read
+    client_cert = File.open(client_cert_path).read
+
+    allow(GRPC::Core::ChannelCredentials).to receive(:new).
+      with(client_ca, client_key, client_cert).
+      and_return(credentials)
+
+    allow(Models::Locket::Stub).to receive(:new).
+      with("#{host}:#{port}", credentials).
+      and_return(locket_service)
+  end
+
+  after do
+    client.stop
+  end
+
+  describe '#start' do
+    it 'continuously attempts to re-acquire the lock' do
+      allow(locket_service).to receive(:lock)
+      allow(client).to receive(:sleep)
+
+      client.start(key, owner)
+      sleep 0.1
+
+      expect(locket_service).to have_received(:lock).with(lock_request).at_least(3).times
+    end
+
+    it 'raises an error when restarted after it has already been started' do
+      client.start(key, owner)
+
+      expect { client.start(key, owner) }.to raise_error(Locket::LockRunner::Error, 'Cannot start more than once')
+    end
+  end
+
+  describe '#lock_acquired?' do
+    context 'initialization' do
+      it 'does not report that it has a lock before start is called' do
+        expect(client.lock_acquired?).to be(false)
+      end
+    end
+
+    context 'when attempting to acquire a lock' do
+      let(:fake_logger) { instance_double(Steno::Logger, debug: nil) }
+
+      before do
+        allow(Steno).to receive(:logger).and_return(fake_logger)
+        allow(client).to receive(:sleep)
+      end
+
+      context 'when it does not acquire a lock' do
+        it 'does not report that it has a lock' do
+          error = GRPC::BadStatus.new(GRPC::AlreadyExists)
+          client.instance_variable_set(:@lock_acquired, true)
+          allow(locket_service).to receive(:lock).
+            and_raise(error)
+
+          client.start(key, owner)
+          sleep 0.1
+
+          expect(client.lock_acquired?).to be(false)
+          expect(fake_logger).to have_received(:debug).with("Failed to acquire lock '#{key}' for owner '#{owner}': #{error.message}").at_least(:once)
+        end
+      end
+
+      context 'when it does acquire a lock' do
+        it 'reports that it has a lock' do
+          allow(locket_service).to receive(:lock).
+            and_return(Models::LockResponse)
+
+          client.start(key, owner)
+          sleep 0.1
+
+          expect(client.lock_acquired?).to be(true)
+          expect(fake_logger).to have_received(:debug).with("Acquired lock '#{key}' for owner '#{owner}'").at_least(:once)
+        end
+      end
+    end
+  end
+end