receptor_controller-client 0.0.2

data/lib/receptor_controller/client/version.rb

@@ -0,0 +1,5 @@
+module ReceptorController
+  class Client
+    VERSION = "0.0.2".freeze
+  end
+end

data/receptor_controller-client.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+=begin
+# Receptor-Controller Client
+=end
+
+$:.push File.expand_path("../lib", __FILE__)
+require "receptor_controller/client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "receptor_controller-client"
+  s.version     = ReceptorController::Client::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Martin Slemr"]
+  s.email       = ["mslemr@redhat.com"]
+  s.homepage    = "https://github.com/RedHatInsights/receptor_controller-client-ruby"
+  s.summary     = "Client for communication with Platform Receptor Controller - Gem"
+  s.description = "Client for communication with Platform Receptor Controller"
+  s.license     = "Apache-2.0"
+  s.required_ruby_version = ">= 2.5"
+
+  s.add_runtime_dependency 'activesupport', '~> 5.2.4.3'
+  s.add_runtime_dependency 'concurrent-ruby', '~> 1.1', '>= 1.1.6'
+  s.add_runtime_dependency 'faraday', '~> 1.0'
+  s.add_runtime_dependency 'json', '~> 2.3', '>= 2.3.0'
+  s.add_runtime_dependency 'manageiq-loggers', '~> 0.5.0'
+  s.add_runtime_dependency 'manageiq-messaging', '~> 0.1.5'
+
+  s.add_development_dependency 'bundler', '~> 2.0'
+  s.add_development_dependency 'rake', '>= 12.3.3'
+  s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0'
+  s.add_development_dependency 'rubocop', '~>0.69.0'
+  s.add_development_dependency 'rubocop-performance', '~>1.3'
+  s.add_development_dependency 'simplecov', '~> 0.17.1'
+  s.add_development_dependency 'webmock'
+
+  s.files         = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+  s.test_files    = `find spec/*`.split("\n")
+  s.executables   = []
+  s.require_paths = ["lib"]
+end

data/spec/receptor_controller/client_spec.rb

@@ -0,0 +1,87 @@
+require "receptor_controller/client"
+
+RSpec.describe ReceptorController::Client do
+  let(:external_tenant) { '0000001' }
+  let(:organization_id) { '000001' }
+  let(:identity) do
+    {"x-rh-identity" => Base64.strict_encode64({"identity" => {"account_number" => external_tenant, "user" => {"is_org_admin" => true}, "internal" => {"org_id" => organization_id}}}.to_json)}
+  end
+  let(:headers) do
+    {"Content-Type"    => "application/json",
+     "Accept"          => "*/*",
+     "Accept-Encoding" => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'}.merge(identity)
+  end
+  let(:receptor_scheme) { 'http' }
+  let(:receptor_host) { 'localhost:9090' }
+  let(:receptor_node) { 'testing-receptor' }
+  let(:receptor_config) do
+    ReceptorController::Client::Configuration.new do |config|
+      config.controller_scheme = receptor_scheme
+      config.controller_host   = receptor_host
+    end
+  end
+  let(:satellite_uid) { '1234567890' }
+
+  subject { described_class.new(:config => receptor_config) }
+
+  before do
+    subject.identity_header = identity
+  end
+
+  describe "#connection_status" do
+    it "makes a POST request to receptor and returns status key-value if successful" do
+      response = {"status" => "connected"}
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/connection/status")
+        .with(:body    => {"account" => external_tenant, "node_id" => receptor_node}.to_json,
+              :headers => headers)
+        .to_return(:status => 200, :body => response.to_json, :headers => {})
+
+      expect(subject.connection_status(external_tenant, receptor_node)).to eq(response)
+    end
+
+    it "makes a POST request to receptor and returns disconnected status in case of error" do
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/connection/status")
+        .with(:body    => {"account" => external_tenant, "node_id" => receptor_node}.to_json,
+              :headers => headers)
+        .to_return(:status => 401, :body => {"errors" => [{"status" => 401, "detail" => "Unauthorized"}]}.to_json, :headers => {})
+
+      expect(subject.connection_status(external_tenant, receptor_node)).to eq(described_class::STATUS_DISCONNECTED)
+    end
+
+    it "makes a POST request and returns disconnected if receptor unavailable" do
+      allow(Faraday).to receive(:post).and_raise(Faraday::ConnectionFailed, "Failed to open TCP connection to #{receptor_host}")
+
+      expect(subject.connection_status(external_tenant, receptor_node)).to eq(described_class::STATUS_DISCONNECTED)
+    end
+  end
+
+  describe "#directive" do
+    it "creates blocking or non-blocking directive" do
+      %i[blocking non_blocking].each do |type|
+        directive = subject.directive(nil,
+                                      nil,
+                                      :payload   => nil,
+                                      :directive => 'xxx',
+                                      :type      => type)
+        klass     = type == :blocking ? ReceptorController::Client::DirectiveBlocking : ReceptorController::Client::DirectiveNonBlocking
+        expect(directive).to be_a_kind_of(klass)
+      end
+    end
+  end
+
+  describe "#headers" do
+    let(:pre_shared_key) { '123456789' }
+
+    it "uses identity_header if PSK is not provided" do
+      expect(subject.headers).to eq({"Content-Type" => "application/json"}.merge(identity))
+    end
+
+    it "uses pre-shared key if provided" do
+      subject.config.configure do |config|
+        config.pre_shared_key = pre_shared_key
+      end
+
+      expect(subject.headers("000001")).to eq("Content-Type" => "application/json", "x-rh-receptor-controller-account" => "000001", "x-rh-receptor-controller-client-id" => "topological-inventory", "x-rh-receptor-controller-psk" => "123456789")
+    end
+  end
+end

data/spec/receptor_controller/directive_blocking_spec.rb

@@ -0,0 +1,197 @@
+require "receptor_controller/client/directive_blocking"
+
+RSpec.describe ReceptorController::Client::DirectiveBlocking do
+  # TODO: definitions below contain the same like non-blocking spec
+  let(:external_tenant) { '0000001' }
+  let(:organization_id) { '000001' }
+  let(:identity) do
+    {"x-rh-identity" => Base64.strict_encode64({"identity" => {"account_number" => external_tenant, "user" => {"is_org_admin" => true}, "internal" => {"org_id" => organization_id}}}.to_json)}
+  end
+  let(:headers) do
+    {"Content-Type"    => "application/json",
+     "Accept"          => "*/*",
+     "Accept-Encoding" => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'}.merge(identity)
+  end
+  let(:receptor_scheme) { 'http' }
+  let(:receptor_host) { 'localhost:9090' }
+  let(:receptor_node) { 'testing-receptor' }
+  let(:receptor_config) do
+    ReceptorController::Client::Configuration.new do |config|
+      config.controller_scheme = receptor_scheme
+      config.controller_host   = receptor_host
+    end
+  end
+  let(:receptor_client) do
+    client = ReceptorController::Client.new(:config => receptor_config)
+    client.identity_header = identity
+    client
+  end
+
+  let(:payload) { {'method' => :get, 'url' => 'tower.example.com', 'headers' => {}, 'ssl' => false}.to_json }
+  let(:directive) { 'receptor_http:execute' }
+
+  subject { described_class.new(:name => directive, :account => external_tenant, :node_id => receptor_node, :payload => payload, :client => receptor_client) }
+
+  describe "#call" do
+    it "makes POST /job request to receptor and registers received message ID" do
+      allow(subject).to receive(:wait_for_response)
+
+      response = {"id" => '1234'}
+
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/job")
+        .with(:body    => subject.default_body.to_json,
+              :headers => headers)
+        .to_return(:status => 200, :body => response.to_json, :headers => {})
+
+      expect(subject.response_worker).to receive(:register_message).with(response['id'], subject)
+
+      subject.call
+    end
+
+    it "raises ControllerResponseError if POST /job returns error" do
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/job")
+        .with(:body    => subject.default_body.to_json,
+              :headers => headers)
+        .to_return(:status => 401, :body => {"errors" => [{"status" => 401, "detail" => "Unauthorized"}]}.to_json, :headers => {})
+
+      expect(subject.response_worker).not_to receive(:register_message)
+
+      expect { subject.call }.to raise_error(ReceptorController::Client::ControllerResponseError)
+    end
+
+    context "waiting for callbacks" do
+      let(:http_response) { {"id" => '1234'} }
+      let(:kafka_client) { double("Kafka client") }
+      let(:kafka_response) { double("Kafka response") }
+
+      before do
+        stub_request(:post, "#{receptor_scheme}://#{receptor_host}/job")
+          .with(:body    => subject.default_body.to_json,
+                :headers => headers)
+          .to_return(:status => 200, :body => http_response.to_json, :headers => {})
+
+        allow(kafka_response).to receive(:ack)
+
+        allow(ManageIQ::Messaging::Client).to receive(:open).and_return(kafka_client)
+        allow(kafka_client).to receive(:subscribe_topic).and_yield(kafka_response)
+        allow(kafka_client).to receive(:close)
+      end
+
+      it "waits for successful response and sets data" do
+        response_message = {'code'           => 0,
+                            'in_response_to' => http_response['id'],
+                            'message_type'   => subject.class::MESSAGE_TYPE_RESPONSE,
+                            'payload'        => 'Test payload'}
+
+        allow(kafka_response).to receive(:payload).and_return(response_message.to_json)
+
+        expect(subject).to(receive(:response_success)
+                             .with(response_message['in_response_to'],
+                                   response_message['message_type'],
+                                   response_message['payload'])
+                             .and_wrap_original) do |m, *args|
+          m.call(*args) # Doesn't release lock, only EOF response can
+          subject.send(:response_waiting).signal
+          subject.response_worker.stop
+        end
+
+        subject.response_worker.start
+        subject.call
+
+        expect(subject.send(:response_data)).to eq(response_message['payload'])
+        expect(subject.send(:response_exception)).to be_nil
+      end
+
+      it "waits for EOF response" do
+        response_message = {'code'           => 0,
+                            'in_response_to' => http_response['id'],
+                            'message_type'   => subject.class::MESSAGE_TYPE_EOF,
+                            'payload'        => 'Unimportant'}
+
+        allow(kafka_response).to receive(:payload).and_return(response_message.to_json)
+
+        expect(subject).to(receive(:response_success)
+                             .with(response_message['in_response_to'],
+                                   response_message['message_type'],
+                                   response_message['payload'])
+                             .and_wrap_original) do |m, *args|
+          m.call(*args) # original call releases lock
+          subject.response_worker.stop
+        end
+
+        subject.response_worker.start
+        subject.call
+
+        expect(subject.send(:response_data)).to be_nil
+        expect(subject.send(:response_exception)).to be_nil
+      end
+
+      it "raises UnknownResponseTypeError if unknown successful response received" do
+        response_message = {'code'           => 0,
+                            'in_response_to' => http_response['id'],
+                            'message_type'   => 'unknown',
+                            'payload'        => 'Unimportant'}
+
+        allow(kafka_response).to receive(:payload).and_return(response_message.to_json)
+
+        expect(subject).to(receive(:response_success)
+                             .with(response_message['in_response_to'],
+                                   response_message['message_type'],
+                                   response_message['payload'])
+                             .and_wrap_original) do |m, *args|
+          m.call(*args) # original call releases lock
+          subject.response_worker.stop
+        end
+
+        subject.response_worker.start
+        expect { subject.call }.to raise_error(ReceptorController::Client::UnknownResponseTypeError)
+
+        expect(subject.send(:response_data)).to be_nil
+        expect(subject.send(:response_exception)).to be_kind_of(ReceptorController::Client::UnknownResponseTypeError)
+      end
+
+      it "raises ResponseError if error response received" do
+        response_message = {'code'           => 1,
+                            'in_response_to' => http_response['id'],
+                            'payload'        => 'Some error message'}
+
+        allow(kafka_response).to receive(:payload).and_return(response_message.to_json)
+
+        expect(subject).to(receive(:response_error)
+                             .with(response_message['in_response_to'],
+                                   response_message['code'],
+                                   response_message['payload'])
+                             .and_wrap_original) do |m, *args|
+          m.call(*args) # original calls releases lock
+          subject.response_worker.stop
+        end
+
+        subject.response_worker.start
+        expect { subject.call }.to raise_error(ReceptorController::Client::ResponseError)
+
+        expect(subject.send(:response_data)).to be_nil
+        expect(subject.send(:response_exception)).to be_kind_of(ReceptorController::Client::ResponseError)
+      end
+
+      it "raises ResponseTimeoutError if timeout response received" do
+        receptor_client.config.response_timeout = 1.second
+        receptor_client.config.response_timeout_poll_time = 0
+
+        allow(kafka_client).to receive(:subscribe_topic).and_return(nil)
+
+        expect(subject).to(receive(:response_timeout)
+                             .with(http_response['id'])
+                             .and_wrap_original) do |m, *args|
+          m.call(*args) # original call releases lock
+          subject.response_worker.stop
+        end
+
+        subject.response_worker.start
+        expect { subject.call }.to raise_error(ReceptorController::Client::ResponseTimeoutError)
+
+        expect(subject.send(:response_data)).to be_nil
+        expect(subject.send(:response_exception)).to be_kind_of(ReceptorController::Client::ResponseTimeoutError)
+      end
+    end
+  end
+end

data/spec/receptor_controller/directive_non_blocking_spec.rb

@@ -0,0 +1,160 @@
+require "receptor_controller/client/directive_non_blocking"
+
+RSpec.describe ReceptorController::Client::DirectiveNonBlocking do
+  let(:external_tenant) { '0000001' }
+  let(:organization_id) { '000001' }
+  let(:identity) do
+    {"x-rh-identity" => Base64.strict_encode64({"identity" => {"account_number" => external_tenant, "user" => {"is_org_admin" => true}, "internal" => {"org_id" => organization_id}}}.to_json)}
+  end
+  let(:headers) do
+    {"Content-Type"    => "application/json",
+     "Accept"          => "*/*",
+     "Accept-Encoding" => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'}.merge(identity)
+  end
+  let(:receptor_scheme) { 'http' }
+  let(:receptor_host) { 'localhost:9090' }
+  let(:receptor_node) { 'testing-receptor' }
+  let(:receptor_config) do
+    ReceptorController::Client::Configuration.new do |config|
+      config.controller_scheme = receptor_scheme
+      config.controller_host   = receptor_host
+    end
+  end
+  let(:receptor_client) do
+    client = ReceptorController::Client.new
+    client.identity_header = identity
+    client
+  end
+
+  let(:satellite_uid) { '1234567890' }
+  let(:payload) { {'satellite_instance_id' => satellite_uid.to_s}.to_json }
+  let(:directive) { 'receptor_satellite:health_check' }
+
+  subject { described_class.new(:name => directive, :account => external_tenant, :node_id => receptor_node, :payload => payload, :client => receptor_client) }
+
+  describe "#call" do
+    it "makes POST /job request to receptor, registers received message ID and returns it" do
+      response = {"id" => '1234'}
+
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/job")
+        .with(:body    => subject.default_body.to_json,
+              :headers => headers)
+        .to_return(:status => 200, :body => response.to_json, :headers => {})
+
+      expect(subject.response_worker).to receive(:register_message).with(response['id'], subject)
+
+      expect(subject.call).to eq(response['id'])
+    end
+
+    it "makes POST /job request to receptor, doesn't register message and returns nil in case of error" do
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/job")
+        .with(:body    => subject.default_body.to_json,
+              :headers => headers)
+        .to_return(:status => 401, :body => {"errors" => [{"status" => 401, "detail" => "Unauthorized"}]}.to_json, :headers => {})
+
+      expect(subject.response_worker).not_to receive(:register_message)
+
+      expect(subject.call).to be_nil
+    end
+
+    it "makes a POST request and returns disconnected if receptor unavailable" do
+      allow(Faraday).to receive(:post).and_raise(Faraday::ConnectionFailed, "Failed to open TCP connection to #{receptor_host}")
+
+      expect(subject.response_worker).not_to receive(:register_message)
+
+      expect(subject.call).to be_nil
+    end
+  end
+
+  context "callbacks" do
+    let(:response_id) { '1234' }
+    let(:response) { double('Kafka response', :ack => nil) }
+
+    before do
+      # HTTP request
+      stub_request(:post, "#{receptor_scheme}://#{receptor_host}/job")
+        .with(:body    => subject.default_body.to_json,
+              :headers => headers)
+        .to_return(:status => 200, :body => {'id' => response_id}.to_json, :headers => {})
+
+      subject.call
+    end
+
+    it "calls success/eof blocks" do
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+
+      # Callbacks
+      result = {}
+      subject
+        .on_success do |msg_id, payload|
+          result[:first] = {:id => msg_id, :payload => payload}
+        end
+        .on_success do |msg_id, payload|
+          result[:second] = {:id => msg_id, :payload => payload}
+        end
+        .on_eof do |msg_id|
+          result[:eof] = {:id => msg_id}
+          mutex.synchronize { cv.signal }
+        end
+
+      # Kafka response - 'response' type
+      expect(subject).to receive(:response_success).twice.and_call_original
+      message_type, payload = 'response', 'Testing payload'
+      response_payload = {'code' => 0, 'in_response_to' => response_id, 'message_type' => message_type, 'payload' => payload}
+      allow(response).to receive(:payload).and_return(response_payload.to_json)
+      subject.response_worker.send(:process_message, response)
+
+      # Kafka response - 'eof' type
+      message_type = 'eof'
+      response_payload = {'code' => 0, 'in_response_to' => response_id, 'message_type' => message_type, 'payload' => nil}
+      allow(response).to receive(:payload).and_return(response_payload.to_json)
+      subject.response_worker.send(:process_message, response)
+
+      mutex.synchronize { cv.wait(mutex) }
+
+      # Result containing both "on_success" blocks
+      block_result = {:id => response_id, :payload => payload}
+      expect(result).to eq(:first  => block_result,
+                           :second => block_result,
+                           :eof    => {:id => response_id})
+    end
+
+    it "processes eof blocks always after all success blocks" do
+      success_cnt = Concurrent::AtomicFixnum.new(0)
+
+      success_calls = 3
+
+      mutex = Mutex.new
+      cv = ConditionVariable.new
+
+      # Callbacks
+      subject
+        .on_success do |_msg_id, _payload|
+          success_cnt.increment
+        end
+        .on_eof do |_msg_id|
+          # Tests
+          expect(success_cnt.value).to eq(success_calls)
+
+          mutex.synchronize { cv.signal }
+        end
+
+      # Kafka response - 'response' type - success
+      message_type, payload = 'response', 'Testing payload'
+      response_payload = {'code' => 0, 'in_response_to' => response_id, 'message_type' => message_type, 'payload' => payload}
+      allow(response).to receive(:payload).and_return(response_payload.to_json)
+      success_calls.times do
+        subject.response_worker.send(:process_message, response)
+      end
+
+      # Kafka response - 'eof' type
+      message_type = 'eof'
+      response_payload = {'code' => 0, 'in_response_to' => response_id, 'message_type' => message_type, 'payload' => nil}
+      allow(response).to receive(:payload).and_return(response_payload.to_json)
+      subject.response_worker.send(:process_message, response)
+
+      mutex.synchronize { cv.wait(mutex) }
+    end
+  end
+end