ruby_nos 0.0.1

data/spec/ruby_nos/message_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe "RubyNos::Message" do
+
+  describe "create_message" do
+    let(:params) {{:from => "Alice", :to => "Bob"}}
+    let(:message) {Message.new(params)}
+    it "creates a message with all the specified fields" do
+      expect(message.from).to eq("Alice")
+      expect(message.to).to eq("Bob")
+    end
+
+    context "using the keys of the message" do
+      let(:message) {Message.new(v: "1.0", fr: "someone")}
+      it "allows to put the value in the correct attribute" do
+        expect(message.version).to eq("1.0")
+        expect(message.from).to eq("someone")
+      end
+    end
+  end
+
+  describe "#serialize" do
+    let(:message) {Message.new}
+    it "returns the serialized message with the keys that have a value" do
+      expect(message.serialize.keys).to eq([:v, :hp, :ts, :rx, :sg])
+    end
+
+    it "adds a signature to each message" do
+      expect_any_instance_of(SignatureGenerator).to receive(:generate_signature)
+      message.serialize
+    end
+
+    it "adds a timestamp to each message" do
+      expect(Formatter).to receive(:timestamp)
+      message.serialize
+    end
+
+    context "with all the fields" do
+      let(:params) {{:from => "Alice", :to => "Bob", :type => "PRS", :data => {a: "something"}}}
+      let(:message) {Message.new(params)}
+
+      it "returns the serialized message with all the keys" do
+        expect(message.serialize.keys).to eq([:v, :ty, :fr, :to, :hp, :ts, :rx, :dt, :sg])
+      end
+    end
+  end
+end

data/spec/ruby_nos/processor_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+require "json"
+
+describe RubyNos::Processor do
+  subject{Processor.new(agent)}
+  let(:agent)                       {Agent.new(:uuid => agent_uuid)}
+  let(:json_message)                {message.to_json}
+  let(:udp_socket)                  {double("UDPSocket", :receptor_address => [12345, "localhost"])}
+  let(:cloud)                       {double("Cloud", :uuid => cloud_uuid, list: list)}
+  let(:list)                        {double("list")}
+  let(:agent_uuid)                  {SecureRandom.uuid}
+  let(:cloud_uuid)                  {SecureRandom.uuid}
+  let(:received_agent_uuid)         {agent_uuid.gsub("-", "")}
+  let(:another_agent_uuid)          {SecureRandom.uuid}
+  let(:another_agent_uuid_received) {another_agent_uuid.gsub("-", "")}
+  let(:received_cloud_uuid)         {cloud_uuid.gsub("-", "")}
+  let(:basic_message_to_agent)               {{from: "AGT:#{another_agent_uuid_received}", to: "AGT:#{received_agent_uuid}", timestamp: "something"}}
+  let(:basic_message_to_cloud)               {{from: "AGT:#{another_agent_uuid_received}", to: "CLD:#{received_cloud_uuid}", timestamp: "something"}}
+  let(:cloud_info) {{agent_uuid: another_agent_uuid, info: nil, timestamp: "something"}}
+
+  before(:each) do
+    allow_any_instance_of(UDPSender).to receive(:send).and_return(nil)
+    agent.udp_rx = udp_socket
+    agent.cloud = cloud
+  end
+
+  describe "#process_message" do
+    let(:message){Message.new({type: "PIN"}.merge(basic_message_to_agent)).serialize}
+    it "checks the signature of the messages" do
+      expect_any_instance_of(SignatureGenerator).to receive(:valid_signature?)
+      subject.process_message(json_message)
+    end
+
+    context "PING message arrives" do
+      let(:message){Message.new({type: "PIN"}.merge(basic_message_to_agent)).serialize}
+      it "it sends a PON" do
+        expect(cloud).to receive(:update).with(cloud_info)
+        expect(agent).to receive(:send_message).with({:type => "PON"})
+        subject.process_message(json_message)
+      end
+    end
+
+    context "PONG messages arrives" do
+      let(:message){Message.new({type: "PON"}.merge(basic_message_to_cloud)).serialize}
+      it "it updates the cloud list" do
+        expect(cloud).to receive(:update).with(cloud_info)
+        subject.process_message(json_message)
+      end
+    end
+
+    context "Discovery message arrives" do
+      let(:message){Message.new({type: "DSC"}.merge(basic_message_to_cloud)).serialize}
+      it "it updates the cloud if the user is not on the list and sends a PRS" do
+        expect(list).to receive(:is_on_the_list?).with(another_agent_uuid)
+        expect(cloud).to receive(:update).with(cloud_info)
+        expect(agent).to receive(:send_message).with({:type => "PRS"})
+        subject.process_message(json_message)
+      end
+    end
+
+    context "#Presence message arrives" do
+      let(:message) {Message.new({type: "PRS", data: {:ap => "example_app"}}.merge(basic_message_to_cloud)).serialize}
+      let(:cloud_info_with_endpoints) {{agent_uuid: another_agent_uuid, info: {:ap => "example_app"}, timestamp: "something"}}
+      it "store the information of the agent and update the list" do
+        expect(cloud).to receive(:update).with(cloud_info_with_endpoints)
+        subject.process_message(json_message)
+      end
+
+      context "#present equals false" do
+        let(:message) {Message.new({type: "PRS", data: {:ap => "example_app", :present => 0}}.merge(basic_message_to_cloud)).serialize}
+        it "eliminates the agent from the cloud if present field is equal to false" do
+          expect(list).to receive(:eliminate).with(another_agent_uuid)
+          subject.process_message(json_message)
+        end
+      end
+    end
+
+    context "#Enquiry message arrives" do
+      let(:message) {Message.new({type: "ENQ"}.merge(basic_message_to_cloud)).serialize}
+      it "returns a QNE message" do
+        expect(cloud).to receive(:update).with(cloud_info)
+        expect(agent).to receive(:send_message).with({:type => "QNE"})
+        subject.process_message(json_message)
+      end
+    end
+
+    context "#Answer to an enquiry message arrives" do
+      let(:rest_api) {RestApi.new}
+      let(:endpoint_params) {{path: "/example", type: "PUBLIC", port: 5000, host: "localhost"}}
+      let(:message) {Message.new({type: "QNE", data: rest_api.to_hash}.merge(basic_message_to_cloud)).serialize}
+      let(:remote_agent) {double("remote_agent")}
+
+      before(:each) do
+        rest_api.add_endpoint(endpoint_params)
+      end
+
+      it "stores the information of the api in the remote agent" do
+        expect(RemoteAgent).to receive(:new).with(uuid: another_agent_uuid, timestamp: "something", rest_api: an_instance_of(RestApi)).and_return(remote_agent)
+        expect(cloud).to receive(:update).with(remote_agent)
+        subject.process_message(json_message)
+      end
+    end
+  end
+end

data/spec/ruby_nos/remote_agent_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe "#RubyNos::RemoteAgent" do
+  subject{RemoteAgent.new}
+
+  describe "#add_endpoint" do
+    it "adds and endpoint to the list of endpoints for the remote agent" do
+      subject.add_endpoint({type: "UDP"})
+      expect(subject.endpoints.count).to eq(1)
+    end
+  end
+
+  describe "#endpoints collection" do
+    it "shows the endpoints as an array of hashes" do
+      subject.add_endpoint({type: "UDP"})
+      expect(subject.endpoints_collection.first.keys).to eq([:pa, :po, :st, :ty, :xp, :ho])
+    end
+  end
+
+  context "#comparing agents" do
+    let(:another_agent){RemoteAgent.new({timestamp: 2, endpoints: [Endpoint.new({type: "HTTP"})], rest_api: RestApi.new})}
+
+    before do
+      subject.endpoints = [Endpoint.new({type: "UDP"})]
+      subject.rest_api = RestApi.new
+      subject.timestamp = 1
+    end
+
+    describe "#same_timestamp?" do
+      it "compares the timestamp with another agent" do
+        expect(subject.same_timestamp?(subject)).to eq(true)
+        expect(subject.same_timestamp?(another_agent)).to eq(false)
+      end
+    end
+
+    describe "#same_endpoints?" do
+      it "compares the timestamp with another agent" do
+        expect(subject.same_endpoints?(subject)).to eq(true)
+        expect(subject.same_endpoints?(another_agent)).to eq(false)
+      end
+    end
+
+    context "#check API" do
+      before(:each) do
+        subject.rest_api.add_endpoint({type: "PUBLIC"})
+        another_agent.rest_api.add_endpoint({type: "HEALTHCHECK"})
+      end
+
+      describe "#same_api?" do
+        it "compares the timestamp with another agent" do
+          expect(subject.same_api?(subject)).to eq(true)
+          expect(subject.same_api?(another_agent)).to eq(false)
+        end
+      end
+    end
+  end
+end

data/spec/ruby_nos/rest_api_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe "#RubyNos::RestApi" do
+  subject{RestApi.new}
+
+  describe "#add_endpoint" do
+    it "creates a new Endpoint and add it to the list of endpoints" do
+      subject.add_endpoint(path: "/this_path", type: "PUBLIC", port: 3000)
+      expect(subject.endpoints.count).to eq(1)
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns the name of the microservices and the list of endpoints on a hash" do
+      expect(subject.to_hash.keys).to eq([:name, :apis])
+    end
+
+    it "returns the list of endpoints in an array" do
+      subject.add_endpoint(path: "/this_path", type: "PUBLIC", port: 3000)
+      expect(subject.to_hash[:apis].first[:pa]).to eq("/this_path")
+    end
+  end
+end

data/spec/ruby_nos/signature_generator_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe "RubyNos#SignGenerator" do
+  subject{SignatureGenerator.new}
+  let(:message) {"Example message"}
+
+  before do
+    subject.key = "key"
+  end
+
+  describe "#generate_signature" do
+    it "generates a signature for a message" do
+       expect(subject.generate_signature(message).size).to eq(40)
+    end
+  end
+
+  describe "#valid_signature?" do
+    it "returns true if the signature is correct" do
+      digest = OpenSSL::Digest.new('sha1')
+      signature = OpenSSL::HMAC.hexdigest(digest, subject.key, message)
+      expect(subject.valid_signature?(message, signature)).to eq(true)
+    end
+
+    it "returns false if the signature is incorrect" do
+      expect(subject.valid_signature?(message, "example")).to eq(false)
+    end
+  end
+end

data/spec/ruby_nos/udp_receptor_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe RubyNos::UDPReceptor do
+
+  subject{UDPReceptor.new}
+
+  describe "#receive" do
+    let(:socket_tx) {UDPSocket.open}
+    let(:message)   {"Example message"}
+    let(:host)      {"230.31.32.33"}
+    let(:port)      {3784}
+    let(:processor) {double("processor")}
+
+    before(:each) do
+      socket_tx.setsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL, 1)
+    end
+
+    after(:each) do
+      subject.socket.close
+      socket_tx.close
+    end
+
+    it "receives messages listening to multicast address" do
+      allow(processor).to receive(:process_message)
+      expect(processor).to receive(:process_message).and_raise("Boom")
+      thread = subject.listen(processor)
+      socket_tx.send(message, 0, host, port)
+      expect{thread.join}.to raise_error("Boom")
+    end
+  end
+end

data/spec/ruby_nos/udp_sender_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require 'ipaddr'
+require 'json'
+
+describe RubyNos::UDPSender do
+
+  subject{UDPSender.new}
+
+  describe "#send" do
+    let(:message) {{message: Message.new.serialize}}
+
+    context "multicast address by default" do
+      let(:host)      {"230.31.32.33"}
+      let(:bind_addr) {"0.0.0.0"}
+      let(:port)      {3784}
+      let(:socketrx)  {UDPSocket.new}
+
+      before(:each) do
+        membership = IPAddr.new(host).hton + IPAddr.new(bind_addr).hton
+        socketrx.setsockopt(:IPPROTO_IP, :IP_ADD_MEMBERSHIP, membership)
+        socketrx.bind(bind_addr, port)
+      end
+
+      after(:each) do
+        socketrx.close
+      end
+
+      it "sends to group address by default" do
+        subject.send(message)
+        expect(socketrx.recvfrom(512).first). to eq(message[:message].to_json)
+        sleep 0.2
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rspec'
+require 'pry'
+require "codeclimate-test-reporter"
+
+ENV['RACK_ENV'] = 'test'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH << File.join(File.dirname(__FILE__),'..')
+CodeClimate::TestReporter.start if !!ENV['CODECLIMATE_REPO_TOKEN']
+require 'config/environment'
+include RubyNos
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+  config.formatter = :documentation # :documentation, :progress, :html, :textmate
+end
+
+
+

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: ruby_nos
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Workshare's dev team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+description: A gem to provide microservices autodiscovery to Ruby microservices.
+email:
+- _Development@workshare.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- config/environment.rb
+- lib/initializable.rb
+- lib/ruby_nos.rb
+- lib/ruby_nos/agent.rb
+- lib/ruby_nos/aliasing.rb
+- lib/ruby_nos/cloud.rb
+- lib/ruby_nos/endpoint.rb
+- lib/ruby_nos/formatter.rb
+- lib/ruby_nos/list.rb
+- lib/ruby_nos/message.rb
+- lib/ruby_nos/processor.rb
+- lib/ruby_nos/remote_agent.rb
+- lib/ruby_nos/rest_api.rb
+- lib/ruby_nos/signature_generator.rb
+- lib/ruby_nos/udp_receptor.rb
+- lib/ruby_nos/udp_sender.rb
+- lib/ruby_nos/version.rb
+- log/.gitkeep
+- ruby_nos.gemspec
+- spec/ruby_nos.spec.rb
+- spec/ruby_nos/agent_spec.rb
+- spec/ruby_nos/cloud_spec.rb
+- spec/ruby_nos/endpoint_spec.rb
+- spec/ruby_nos/formatter_spec.rb
+- spec/ruby_nos/list_spec.rb
+- spec/ruby_nos/message_spec.rb
+- spec/ruby_nos/processor_spec.rb
+- spec/ruby_nos/remote_agent_spec.rb
+- spec/ruby_nos/rest_api_spec.rb
+- spec/ruby_nos/signature_generator_spec.rb
+- spec/ruby_nos/udp_receptor_spec.rb
+- spec/ruby_nos/udp_sender_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/worshare/ruby-nos
+licenses:
+- Copyright
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A gem to provide microservices autodiscovery to Ruby microservices. This
+  gem allows a microservice to publish its existence on a cloud, store other microservices
+  information and public its API.
+test_files:
+- spec/ruby_nos.spec.rb
+- spec/ruby_nos/agent_spec.rb
+- spec/ruby_nos/cloud_spec.rb
+- spec/ruby_nos/endpoint_spec.rb
+- spec/ruby_nos/formatter_spec.rb
+- spec/ruby_nos/list_spec.rb
+- spec/ruby_nos/message_spec.rb
+- spec/ruby_nos/processor_spec.rb
+- spec/ruby_nos/remote_agent_spec.rb
+- spec/ruby_nos/rest_api_spec.rb
+- spec/ruby_nos/signature_generator_spec.rb
+- spec/ruby_nos/udp_receptor_spec.rb
+- spec/ruby_nos/udp_sender_spec.rb
+- spec/spec_helper.rb
+has_rdoc: