rails-pipeline 1.1.1

data/lib/rails-pipeline/symmetric_encryptor.rb

@@ -0,0 +1,127 @@
+# Mixin to enable symmetric encryption/decryption for pipeline, using protocol
+# buffers on the wire.
+
+require "rails-pipeline/protobuf/encrypted_message.pb"
+
+module RailsPipeline
+
+  module SymmetricEncryptor
+    Error = Class.new(StandardError)
+    NoApiKeyError = Class.new(Error) do
+      def message
+        "You need to set the env variable PIPELINE_API_KEY to emit messages"
+      end
+    end
+
+    class << self
+      # Allow configuration via initializer
+      @@secret = nil
+      def _secret
+        @@secret.nil? ? ENV.fetch("PIPELINE_SECRET", Rails.application.config.secret_token) : @@secret
+      end
+
+      def secret=(secret)
+        @@secret = secret
+      end
+
+      @@api_key = nil
+      def _api_key
+        api_key = @@api_key.nil? ? ENV["PIPELINE_API_KEY"] : @@api_key
+        if api_key.blank?
+          raise NoApiKeyError.new
+        end
+        return api_key
+      end
+
+      def api_key=(api_key)
+        @@api_key = api_key
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def encrypt(plaintext, owner_info: nil, type_info: nil, topic: nil, event_type: nil)
+        # Inititalize a symmetric cipher for encryption
+        cipher = OpenSSL::Cipher::AES256.new(:CBC)
+        cipher.encrypt
+
+        # Create a random salt
+        salt = OpenSSL::Random.random_bytes(16)
+
+        # Create a PKCS5 key from the rails password
+        # NOTE: suggested way of doing this is by cipher.random_key
+        # and then we would store the key on the user.
+        key = _key(salt)
+
+        # Set the key and get a random initialization vector
+        cipher.key = key
+        iv = cipher.random_iv
+
+        # Do the encryption
+        ciphertext = cipher.update(plaintext) + cipher.final
+        uuid = SecureRandom.uuid
+        return RailsPipeline::EncryptedMessage.new(
+          uuid: uuid,
+          salt: Base64.encode64(salt),
+          iv: Base64.encode64(iv),
+          ciphertext: Base64.encode64(ciphertext),
+          owner_info: owner_info,
+          type_info: type_info,
+          topic: topic,
+          event_type: _event_type_value(event_type),
+          api_key: _api_key,
+        )
+      end
+
+      # Message is an instance of EncryptedMessage
+      def decrypt(message)
+        salt = Base64.decode64(message.salt)
+        key = _key(salt)
+        cipher = OpenSSL::Cipher::AES256.new(:CBC)
+        # Initialize for decryption
+        cipher.decrypt
+
+        # Set up key and iv
+        cipher.key = key
+        cipher.iv = Base64.decode64(message.iv)
+
+        # Decrypt
+        decoded = Base64.decode64(message.ciphertext)
+        plaintext = cipher.update(decoded) + cipher.final
+
+        return plaintext
+      end
+
+      def _secret
+        RailsPipeline::SymmetricEncryptor._secret
+      end
+
+      def _api_key
+        RailsPipeline::SymmetricEncryptor._api_key
+      end
+
+      def _key(salt)
+        iter = 10000
+        key_len = 32
+        key = OpenSSL::PKCS5.pbkdf2_hmac_sha1(_secret, salt, iter, key_len)
+        return key
+      end
+
+      def _event_type_value(event_type)
+        case event_type
+        when :create
+          RailsPipeline::EncryptedMessage::EventType::CREATED
+        when :update
+          RailsPipeline::EncryptedMessage::EventType::UPDATED
+        when :destroy
+          RailsPipeline::EncryptedMessage::EventType::DELETED
+        end
+      end
+
+    end
+  end
+end

data/lib/rails-pipeline/version.rb

@@ -0,0 +1,3 @@
+module RailsPipeline
+  VERSION = "1.1.1"
+end

data/lib/tasks/rails-pipeline_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rails-pipeline do
+#   # Task goes here
+# end

data/spec/emitter_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+require_relative 'pipeline_helper'
+
+
+describe RailsPipeline::Emitter do
+  before do
+    @test_emitter = TestEmitter.new({foo: "bar"}, without_protection: true)
+    @test_model = TestModelWithTable.new
+    @default_emitter = DefaultEmitter.new({foo: "baz"}, without_protection: true)
+    TestModelWithTable.pipeline_method_cache = {}
+    TestEmitter.pipeline_method_cache = {}
+    DefaultEmitter.pipeline_method_cache = {}
+  end
+
+  it "should derive the topic name" do
+    TestEmitter.topic_name.should eql "harrys-#{Rails.env}-v1-test_emitters"
+    TestEmitter.topic_name("2_1").should eql "harrys-#{Rails.env}-v2-test_emitters"
+    TestEmitter.topic_name("2").should eql "harrys-#{Rails.env}-v2-test_emitters"
+  end
+
+  it "should detect all pipeline versions in class" do
+    pipeline_versions = TestEmitter.pipeline_versions
+    pipeline_versions.length.should eql 2
+    pipeline_versions.should include "1_1"
+    pipeline_versions.should include "2_0"
+
+    DefaultEmitter.pipeline_versions.length.should eql 1
+    DefaultEmitter.pipeline_versions.should eql ["1_0"]
+  end
+
+  context "with only default version" do
+    it "should produce all attributes" do
+      data = @default_emitter.to_pipeline_1_0
+      expect(data.foo).to eq("baz")
+      expect(data.class).to eq(DefaultEmitter_1_0)
+    end
+
+    it "should emit one version" do
+      @default_emitter.should_receive(:publish).once
+      @default_emitter.emit
+    end
+
+    it "should encrypt the payload" do
+      DefaultEmitter.should_receive(:encrypt).once { |data|
+        obj = DefaultEmitter_1_0.parse(data)
+        expect(obj.foo).to eq "baz"
+      }.and_call_original
+      @default_emitter.should_receive(:publish).once
+      @default_emitter.emit
+    end
+
+    it "should have the correct encrypted payload" do
+      DefaultEmitter.should_receive(:encrypt).once.and_call_original
+      # Just verify that the right encrypted data gets sent to publish
+      @default_emitter.should_receive(:publish).once do |topic, serialized_message|
+        topic.should eql "harrys-#{Rails.env}-v1-default_emitters"
+        message = RailsPipeline::EncryptedMessage.parse(serialized_message)
+        expect(message.type_info).to eq(DefaultEmitter_1_0.to_s)
+
+        plaintext = DefaultEmitter.decrypt(message)
+        obj = DefaultEmitter_1_0.parse(plaintext)
+        expect(obj.foo).to eq("baz")
+      end
+      @default_emitter.emit
+    end
+  end
+
+  context "with defined version" do
+    it "should produce expected version when called explicitly" do
+      data = @test_emitter.to_pipeline_1_1
+      data.foo.should eql "bar"
+      data.extrah.should eql "hi"
+    end
+
+    it "should emit multiple versions" do
+      @test_emitter.should_receive(:publish).twice
+      @test_emitter.emit
+    end
+  end
+
+  context 'event type' do
+    context 'created' do
+      it "sets event type correctly in enveloppe" do
+        @test_model.should_receive(:publish).once do |topic, serialized_message|
+          topic.should eq("harrys-#{Rails.env}-v1-test_model_with_tables")
+          message = RailsPipeline::EncryptedMessage.parse(serialized_message)
+          expect(message.event_type).to eq(RailsPipeline::EncryptedMessage::EventType::CREATED)
+        end
+        @test_model.save!
+      end
+    end
+
+    context 'updated' do
+      it "sets event type correctly in enveloppe" do
+        @test_model.save!
+        expect(@test_model).to receive(:publish).once do |topic, serialized_message|
+          expect(topic).to eq("harrys-#{Rails.env}-v1-test_model_with_tables")
+          message = RailsPipeline::EncryptedMessage.parse(serialized_message)
+          expect(message.event_type).to eq(RailsPipeline::EncryptedMessage::EventType::UPDATED)
+        end
+        @test_model.save!
+      end
+    end
+
+    context 'deleted' do
+      it "sets event type correctly in enveloppe" do
+        @test_model.save!
+        expect(@test_model).to receive(:publish).once do |topic, serialized_message|
+          expect(topic).to eq("harrys-#{Rails.env}-v1-test_model_with_tables")
+          message = RailsPipeline::EncryptedMessage.parse(serialized_message)
+          expect(message.event_type).to eq(RailsPipeline::EncryptedMessage::EventType::DELETED)
+        end
+        @test_model.destroy
+      end
+    end
+  end
+
+  context 'methods cache' do
+    context 'empty cache' do
+      before { @test_model.save! }
+      it 'caches the pipeline versions' do
+        TestModelWithTable.pipeline_method_cache[RailsPipeline::PipelineVersion.new('1_1')].should eq(:to_pipeline_1_1)
+      end
+    end
+
+    context 'non empty cache' do
+
+      before do
+        # warms the cache
+        TestModelWithTable.pipeline_versions
+      end
+      it "reads from cache" do
+        version = RailsPipeline::PipelineVersion.new('1_1')
+        TestModelWithTable.should_not_receive(:instance_methods)
+        # TestModelWithTable.pipeline_method_cache.should_receive(:[]).with(version).once.and_call_original
+        @test_model.save!
+      end
+    end
+  end
+end

data/spec/handlers/activerecord_crud_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'pipeline_helper'
+
+describe RailsPipeline::SubscriberHandler::ActiveRecordCRUD do
+  describe 'handle payload event type' do
+    let(:handler) {
+      RailsPipeline::SubscriberHandler::ActiveRecordCRUD.new(
+        payload, target_class: subscriber.target_class(payload), event_type: event)
+    }
+    let(:subscriber) { TestSubscriber.new }
+    let(:test_message) { test_model.create_message("1_1", event) }
+    let(:payload_str) { subscriber.class.decrypt(test_message) }
+    let(:clazz) { Object.const_get(test_message.type_info) }
+    let(:payload) { clazz.parse(payload_str) }
+
+    before(:each) do
+      RailsPipeline::Subscriber.register(TestEmitter_1_1, TestModelWithTable)
+    end
+
+    after(:each) { TestModelWithTable.delete_all }
+
+    context 'CREATED' do
+      let(:event) { RailsPipeline::EncryptedMessage::EventType::CREATED }
+      let(:test_model) { TestModelWithTable.new({id: 42, foo: 'bar'}, without_protection: true) }
+
+      it "should create an object" do
+        expect {
+          handler.handle_payload
+        }.to change(TestModelWithTable, :count).by(1)
+      end
+
+      it "should create with correct attributes" do
+        new_object = handler.handle_payload
+        new_object.should be_persisted
+        new_object.id.should eq(42)
+        new_object.foo.should eq('bar')
+      end
+
+      it "should log if creation failed" do
+        TestModelWithTable.create({id: 42}, without_protection: true)
+        RailsPipeline.logger.should_receive(:error).with("Could not handle payload: #{payload.inspect}, event_type: #{event}")
+        handler.handle_payload
+      end
+    end
+
+    context 'UPDATED' do
+      let(:event) { RailsPipeline::EncryptedMessage::EventType::UPDATED }
+      let(:test_model) { TestModelWithTable.new({id: 42, foo: 'bar'}, without_protection: true) }
+
+      it "should update existing object" do
+        test_model.save!
+        test_model.foo = 'qux'
+        object = handler.handle_payload
+        object.should be_persisted
+        object.id.should eq(42)
+        object.foo.should eq('qux')
+      end
+
+      it "should log if update failed" do
+        RailsPipeline.logger.should_receive(:error).with("Could not handle payload: #{payload.inspect}, event_type: #{event}")
+        handler.handle_payload
+      end
+    end
+
+    context 'DELETED' do
+      let(:event) { RailsPipeline::EncryptedMessage::EventType::DELETED }
+      let(:test_model) { TestModelWithTable.new({id: 42, foo: 'bar'}, without_protection: true) }
+
+      it "should update existing object" do
+        test_model.save!
+        object = handler.handle_payload
+        object.should be_destroyed
+      end
+
+      it "should log if update failed" do
+        RailsPipeline.logger.should_receive(:error).with("Could not handle payload: #{payload.inspect}, event_type: #{event}")
+        handler.handle_payload
+      end
+    end
+  end
+
+  describe 'attributes' do
+    let(:handler) {
+      RailsPipeline::SubscriberHandler::ActiveRecordCRUD.new(
+      payload, target_class: subscriber.target_class(payload), event_type: event)
+    }
+    let(:subscriber) { TestSubscriber.new }
+    let(:test_model) { TestModelWithTable.new({foo: 'bar'}, without_protection: true) }
+    let(:test_message) { test_model.create_message("1_1", event) }
+    let(:payload_str) { subscriber.class.decrypt(test_message) }
+    let(:clazz) { Object.const_get(test_message.type_info) }
+    let(:payload) { clazz.parse(payload_str) }
+    let(:event) { RailsPipeline::EncryptedMessage::EventType::CREATED }
+
+    it 'converts datetime correctly' do
+      test_model.save!
+      handler._attributes(payload)[:created_at].should be_an_instance_of(DateTime)
+    end
+  end
+end

data/spec/handlers/logger_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'pipeline_helper'
+
+describe RailsPipeline::SubscriberHandler::Logger do
+  describe 'handle payload event type' do
+    let(:handler) {
+      RailsPipeline::SubscriberHandler::Logger.new(
+        payload, envelope: test_message)
+    }
+    let(:test_model) { TestModelWithTable.new({id: 42, foo: 'bar'}, without_protection: true) }
+    let(:subscriber) { TestSubscriber.new }
+    let(:test_message) { test_model.create_message("1_1", event) }
+    let(:payload_str) { subscriber.class.decrypt(test_message) }
+    let(:clazz) { Object.const_get(test_message.type_info) }
+    let(:payload) { clazz.parse(payload_str) }
+
+    context 'CREATED' do
+      let(:event) { RailsPipeline::EncryptedMessage::EventType::CREATED }
+
+      it 'logs everything' do
+        expect(RailsPipeline.logger).to receive(:info).with(test_message.to_s)
+        handler.handle_payload
+      end
+    end
+
+    context 'UPDATED' do
+      let(:event) { RailsPipeline::EncryptedMessage::EventType::UPDATED }
+      it 'logs everything' do
+        expect(RailsPipeline.logger).to receive(:info).with(test_message.to_s)
+        handler.handle_payload
+      end
+    end
+
+    context 'DELETED' do
+      let(:event) { RailsPipeline::EncryptedMessage::EventType::DELETED }
+      it 'logs everything' do
+        expect(RailsPipeline.logger).to receive(:info).with(test_message.to_s)
+        handler.handle_payload
+      end
+    end
+  end
+end

data/spec/ironmp_pulling_subscriber_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe RailsPipeline::IronmqPullingSubscriber do
+    let(:subject){RailsPipeline::IronmqPullingSubscriber.new("test_queue")}
+    let(:failing_proc){Proc.new{false}}
+    let(:successful_proc){Proc.new{true}}
+
+    describe "#start_subscription" do
+        it "should attempt to process a dequeued message" do
+            subject.stub(:pull_message).and_yield("foo")
+            subject.stub(:process_message){subject.deactivate_subscription}
+            subject.start_subscription{}
+            expect(subject).to have_received(:process_message)
+        end
+    end
+
+    describe "#process_message" do
+        context "when receiving a nil message" do
+            it "deactivates the current subscription" do
+                subject.process_message(nil, true, successful_proc)
+                expect(subject.active_subscription?).to eql false
+            end
+        end
+
+        context "when receiving a non-nil message" do
+            context "when an issue occurs while generating an message envelope" do
+                let(:malformed_message){double("message", :body => "a malformed message",
+                                               :delete => "a fine deletion implementation")}
+
+                before(:each) do
+                    subject.activate_subscription
+                    expect {subject.process_message(malformed_message, true, successful_proc)}.to raise_error
+                end
+
+                it "does not delete the message" do
+                    expect(malformed_message).to_not have_received(:delete)
+                end
+
+                it "deactivates the subscription" do
+                    expect(subject.active_subscription?).to eql false
+                end
+            end
+        end
+    end
+
+    describe "#process_envelope" do
+        let(:failing_proc){Proc.new{false}}
+        let(:successful_proc){Proc.new{true}}
+        let(:test_envelope){double("envelope")}
+        let(:message){double("message", :delete => "a deletion implementation")}
+
+        context "when the block passed returns true" do
+            it "deletes the passed message" do
+                subject.process_envelope(test_envelope, message, successful_proc)
+                expect(message).to have_received(:delete)
+            end
+        end
+
+        context "when the block passeed returns false" do
+            it "does not delete the passed message" do
+                subject.process_envelope(test_envelope, message, failing_proc)
+                expect(message).to_not have_received(:delete)
+            end
+        end
+    end
+
+    describe "#active_subscription?" do
+        context "when the subscriber is currently active" do
+            it "returns true" do
+                subject.activate_subscription
+                expect(subject.active_subscription?).to eq true
+            end
+        end
+
+        context "when the subscriber is not currently active" do
+            it "returns false" do
+                subject.deactivate_subscription
+                expect(subject.active_subscription?).to eq false
+            end
+        end
+    end
+
+    describe "activate_subscription" do
+        it "sets the subscription status of the subscriber to true" do
+            subject.deactivate_subscription
+            subject.activate_subscription
+            expect(subject.active_subscription?).to eql true
+        end
+    end
+
+    describe "deactivate_subscription" do
+        it "sets the subscription status of the subscriber to false" do
+            subject.activate_subscription
+            subject.deactivate_subscription
+            expect(subject.active_subscription?).to eql false
+        end
+    end
+end