ruby_nos 0.0.1

data/lib/ruby_nos/signature_generator.rb

@@ -0,0 +1,22 @@
+require "digest"
+
+module RubyNos
+  class SignatureGenerator
+
+    attr_accessor :key
+
+    def key
+      @key ||= RubyNos.signature_key
+    end
+
+    def generate_signature data
+      digest = OpenSSL::Digest.new('sha1')
+      OpenSSL::HMAC.hexdigest(digest, key, data)
+    end
+
+    def valid_signature? data, signature
+      generated_signature = generate_signature(data)
+      signature == generated_signature
+    end
+  end
+end

data/lib/ruby_nos/udp_receptor.rb

@@ -0,0 +1,47 @@
+require 'socket'
+require 'ipaddr'
+
+module RubyNos
+  class UDPReceptor
+    attr_accessor :port
+
+    def initialize
+      configure
+    end
+
+    def port
+      @port ||= RubyNos.port
+    end
+
+    def multicast_address
+      @multicast_address ||= RubyNos.group_address
+    end
+
+    def socket
+      @socket ||= UDPSocket.new
+    end
+
+    def listen processor
+      Thread.new do
+        loop do
+          message = @socket.recvfrom(512).first
+          processor.process_message(message)
+        end
+      end
+    end
+
+    private
+
+    def configure
+      RubyNos.logger.send(:info, "Binding socket to #{bind_addr} IP")
+      membership = IPAddr.new(multicast_address).hton + IPAddr.new(bind_addr).hton
+      socket.setsockopt(:IPPROTO_IP, :IP_ADD_MEMBERSHIP, membership)
+      socket.setsockopt(:SOL_SOCKET, :SO_REUSEADDR, 1)
+      socket.bind(bind_addr, port)
+    end
+
+    def bind_addr
+      "0.0.0.0"
+    end
+  end
+end

data/lib/ruby_nos/udp_sender.rb

@@ -0,0 +1,26 @@
+require 'socket'
+require 'json'
+
+module RubyNos
+  class UDPSender
+  include Initializable
+
+    def send args={}
+      socket = UDPSocket.open
+      socket.setsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL, 1)
+      RubyNos.logger.send(:info, "Message sent: #{args[:message]}")
+      socket.send(args[:message].to_json, 0, args[:host] || multicast_address, args[:port] || port)
+      socket.close
+    end
+
+    private
+
+    def multicast_address
+      @multicast_address ||= RubyNos.group_address
+    end
+
+    def port
+      @port ||= RubyNos.port
+    end
+  end
+end

data/lib/ruby_nos/version.rb

@@ -0,0 +1,3 @@
+module RubyNos
+  VERSION = "0.0.1"
+end

data/ruby_nos.gemspec

@@ -0,0 +1,22 @@
+gem_name = "ruby_nos"
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "#{gem_name}/version"
+
+Gem::Specification.new do |spec|
+  spec.name = gem_name
+  spec.version = RubyNos::VERSION
+  spec.authors = ["Workshare's dev team"]
+  spec.email = ['_Development@workshare.com']
+  spec.description = "A gem to provide microservices autodiscovery to Ruby microservices."
+  spec.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."
+  spec.homepage = "https://github.com/worshare/#{spec.name.gsub('_','-')}"
+  spec.license = "Copyright"
+  spec.files = `git ls-files`.split($/)
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.4"
+end

data/spec/ruby_nos.spec.rb

@@ -0,0 +1,7 @@
+require_relative 'spec_helper'
+
+describe RubyNos do
+  it 'has a version' do
+    expect(RubyNos::VERSION).not_to be_nil
+  end
+end

data/spec/ruby_nos/agent_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe "RubyNos::Agent" do
+  subject{Agent.new(udp_tx: udp_sender, udp_rx: udp_receptor, cloud: cloud, processor: processor, rest_api: rest_api)}
+  let(:udp_receptor)    {double("UDPReceptor", listen: nil)}
+  let(:udp_sender)      {double("UDPSender", send: nil)}
+  let(:cloud)           {double("cloud", uuid: "abcd", list: list)}
+  let(:list)            {double("list", list_of_keys: [])}
+  let(:processor)       {double("processor")}
+  let(:rest_api)        {double("rest_api", endpoints: [], to_hash: {})}
+
+  describe "mantain cloud" do
+    context "without agents on the cloud" do
+      it "ask for other agents" do
+        expect(udp_sender).to receive(:send).twice
+        thread = subject.maintain_cloud
+        sleep 0.1
+        thread.kill
+      end
+    end
+
+    context "with some agent on the cloud" do
+      let(:list)  {double("list", list_of_keys: [agent.uuid])}
+      let(:agent) {double("agent", uuid: "12345", timestamp: Time.now)}
+
+      before(:each) do
+        allow(list).to receive(:info_for).with(agent.uuid).and_return(agent)
+      end
+
+      context "it exists a previous message of the agent" do
+        it "sends_a_ping_message to the agent" do
+          expect(udp_sender).to receive(:send).exactly(3).times
+          allow(subject).to receive(:last_message_exists?).and_return(true)
+          thread = subject.maintain_cloud
+          sleep 0.1
+          thread.kill
+        end
+      end
+
+      context "it does not exists a previous message of the agent" do
+        it "eliminates the agent from the list" do
+          expect(udp_sender).to receive(:send).twice
+          allow(subject).to receive(:last_message_exists?).and_return(false)
+          expect(list).to receive(:eliminate).with(agent.uuid)
+          thread = subject.maintain_cloud
+          sleep 0.1
+          thread.kill
+        end
+      end
+    end
+  end
+
+  describe "#join_cloud" do
+    let(:receptor_info) {{present: 1, endpoints: []}}
+
+    before(:each) do
+      allow(subject).to receive(:receptor_info).and_return(receptor_info)
+    end
+
+    it "sends only a presence message if the agent does not have an API with endpoints" do
+      expect(udp_sender).to receive(:send).once
+      subject.join_cloud
+    end
+
+    it "sends a presence and a qne if the agent has an API with endpoints" do
+      allow(rest_api).to receive(:endpoints).and_return(["one_endpoint"])
+      expect(udp_sender).to receive(:send).twice
+      subject.join_cloud
+    end
+  end
+
+  describe "#send_desconnection_message" do
+    it "sends a message with presence 0" do
+      expect(udp_sender).to receive(:send).once
+      subject.send_desconnection_message
+    end
+  end
+
+
+  describe "#listen" do
+    it "starts the udp receptor" do
+      expect(udp_receptor).to receive(:listen)
+      subject.listen
+    end
+  end
+
+
+  describe "#send_message" do
+    let(:message){double("Message", :serialize => "SerializedMessage")}
+    let(:rest_api) {RestApi.new}
+    let(:receptor_info) {{present: 1, endpoints: []}}
+    let(:well_formed_presence_message){Message.new({from: "AGT:#{subject.uuid.gsub("-", "")}", to: "CLD:#{subject.cloud.uuid.gsub("-", "")}", type: "PRS", timestamp: "sometime", data: receptor_info}).serialize}
+    let(:well_formed_qne_message){Message.new({from: "AGT:#{subject.uuid.gsub("-", "")}", to: "CLD:#{subject.cloud.uuid.gsub("-", "")}", type: "QNE", timestamp: "sometime", data: rest_api.to_hash}).serialize}
+    let(:host) {"0.0.0.0"}
+    let(:port) {"3784"}
+
+    before(:each) do
+      subject.cloud = cloud
+      subject.rest_api = rest_api
+      allow_any_instance_of(Message).to receive(:generate_miliseconds_timestamp).and_return("sometime")
+    end
+
+    it "sends a message using the UDP Socket" do
+      expect(Message).to receive(:new).with({:from => "AGT:#{subject.uuid.gsub("-", "")}", :to => "CLD:#{cloud.uuid.gsub("-", "")}", :type => "DSC"}).and_return(message)
+      expect(udp_sender).to receive(:send).with({host: host, port: port, :message => "SerializedMessage"})
+      subject.send_message({:type => "DSC", :port => port, :host => host})
+    end
+
+    it "add the UDP socket info if it is a presence message" do
+      expect(subject).to receive(:receptor_info).and_return(receptor_info)
+      expect(udp_sender).to receive(:send).with({host: host, port: port, :message => well_formed_presence_message})
+      subject.send_message({:type => "PRS", :port => port, :host => host})
+    end
+
+    it "add the RestAPI info if it is a QNE message" do
+      expect(udp_sender).to receive(:send).with({host: host, port: port, :message => well_formed_qne_message})
+      subject.send_message({:type => "QNE", :port => port, :host => host})
+    end
+  end
+end

data/spec/ruby_nos/cloud_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe "#RubyNos::Cloud" do
+  subject{Cloud.new(uuid:cloud_uuid)}
+  let(:cloud_uuid) {"122445"}
+  let(:agent_uuid) {"12345"}
+  let(:list) {double("list")}
+
+
+  before do
+    subject.list = list
+  end
+
+  describe "#update" do
+
+    describe "new agent" do
+      before do
+        allow(list).to receive(:is_on_the_list?).with(agent_uuid).and_return(false)
+      end
+
+      context "receiving a Hash" do
+        let(:agent_info) {{agent_uuid: agent_uuid, info: info}}
+        let(:info)       {{:endpoints => ["UDP,something,something"]}}
+
+        it "builds a RemoteAgent and stores it on the list" do
+          expect(list).to receive(:add).with(an_instance_of(RemoteAgent))
+          subject.update(agent_info)
+        end
+      end
+
+      context "receiving a RemoteAgent" do
+        let(:agent) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 1, endpoints: [], rest_api: nil)}
+
+        it "stores agents information if it is new" do
+          expect(list).to receive(:add).with(agent)
+          subject.update(agent)
+        end
+      end
+
+    end
+
+    describe "old agent" do
+      let(:agent) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 1, endpoints: [], rest_api: nil)}
+
+      before(:each) do
+        allow(list).to receive(:is_on_the_list?).with(agent_uuid).and_return(true)
+        allow(list).to receive(:info_for).with(agent_uuid).and_return(agent)
+      end
+
+      context "agent updated with correct information" do
+        let(:agent_updated) {instance_double(RemoteAgent, uuid: agent_uuid,  timestamp: 2, endpoints: ["something"], rest_api: nil)}
+
+        it "if the agent exists and the information is not the same it updates to this new information" do
+          expect(subject).to receive(:correct_timestamp?).and_return(true)
+          expect(agent).to receive(:same_endpoints?).with(agent_updated).and_return(false)
+          expect(list).to receive(:update).with(agent_uuid, agent_updated)
+          subject.update(agent_updated)
+        end
+      end
+
+      context "agent updating with the same information" do
+        let(:agent) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 1, endpoints: ["something"], rest_api: nil)}
+        let(:agent_updated) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 2, endpoints: ["something"], rest_api: nil)}
+
+        it "if the agent exists and the information is not the same it updates to this new information" do
+          expect(subject).to receive(:correct_timestamp?).and_return(true)
+          expect(agent).to receive(:same_endpoints?).with(agent_updated).and_return(true)
+          expect(agent).to receive(:same_api?).with(agent_updated).and_return(true)
+          expect(agent).to receive(:same_timestamp?).with(agent_updated).and_return(true)
+          expect(list).to_not receive(:update).with(agent_uuid, agent_updated)
+          subject.update(agent_updated)
+        end
+      end
+
+
+      context "agent updated with nil information" do
+        context "nil endpoints" do
+          let(:agent) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 1, endpoints: ["something"], rest_api: nil)}
+          let(:agent_updated) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 2, endpoints: [], rest_api: nil)}
+
+          it "only overwrite the entry with the new information" do
+            expect(subject).to receive(:correct_timestamp?).and_return(true)
+            expect(agent).to receive(:same_endpoints?).with(agent_updated).and_return(false)
+            expect(agent_updated).to receive(:endpoints=).with(agent.endpoints)
+            expect(list).to receive(:update).with(agent_uuid, agent_updated)
+            subject.update(agent_updated)
+          end
+        end
+
+        context "nil api" do
+          let(:agent) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 1, endpoints: ["something"], rest_api: double("rest_api"))}
+          let(:agent_updated) {instance_double(RemoteAgent, uuid: agent_uuid, timestamp: 2, endpoints: ["something"], rest_api: nil)}
+
+          it "only overwrite the entry with the new information" do
+            expect(subject).to receive(:correct_timestamp?).and_return(true)
+            expect(agent).to receive(:same_endpoints?).with(agent_updated).and_return(true)
+            expect(agent).to receive(:same_api?).and_return(false)
+            expect(agent_updated).to receive(:rest_api=).with(agent.rest_api)
+            expect(list).to receive(:update).with(agent_uuid, agent_updated)
+            subject.update(agent_updated)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/ruby_nos/endpoint_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe "#RubyNos::Endpoint" do
+  subject{Endpoint.new}
+
+  describe "type=" do
+    it "can does not allow types that are not on the allowed types list" do
+      expect{subject.type = "SOMETHING"}.to raise_error(ArgumentError)
+    end
+
+    it "allows to set a type that is on the list" do
+      subject.type = "PUBLIC"
+      expect(subject.type).to eq("PUBLIC")
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns the attributes of the endpoint in a hash" do
+      subject.path = "/example_path"
+      expect(subject.to_hash.keys).to eq([:pa, :po, :st, :ty, :xp, :ho])
+      expect(subject.to_hash[:pa]).to eq("/example_path")
+    end
+  end
+
+  describe "#aliasing" do
+    let(:endpoint_hash) {{pa: "/api/", po: 1234, st: 0, ty: "PUB", xp: 0, ho: "localhost"}}
+
+    it "allows to instantiate an endpoint object attributes with the correct values" do
+      endpoint = Endpoint.new(endpoint_hash)
+      expect(endpoint.port).to eq 1234
+      expect(endpoint.path).to eq "/api/"
+      expect(endpoint.sticky).to eq 0
+      expect(endpoint.type).to eq "PUB"
+      expect(endpoint.priority).to eq 0
+      expect(endpoint.host).to eq "localhost"
+    end
+  end
+end

data/spec/ruby_nos/formatter_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe "#RubyNos::Formatter" do
+  subject{Formatter.new}
+  let(:uuid) {SecureRandom.uuid}
+
+  describe "convert_to_uuid" do
+    let(:string_uuid){uuid.gsub("-", "")}
+    it "converts an string into uuid format" do
+       expect(subject.convert_to_uuid(string_uuid)).to eq uuid
+    end
+  end
+
+  describe "#uuid_format?" do
+    it "returns true if the parameter match the uuid format" do
+      expect(subject.uuid_format?(uuid)).to eq(true)
+    end
+  end
+
+  describe "#uuid_to_string" do
+    it "converts an uuid to string" do
+      result = subject.uuid_to_string(uuid)
+      expect(result.include?("-")).to eq(false)
+      expect(uuid.split("").count - result.split("").count).to eq 4
+    end
+  end
+
+  describe "#parse_message" do
+    let(:message) {{:a => "something"}}
+    it "returns the message as a hash format if it was a hash " do
+      expect(subject.parse_message(message.to_json)).to eq(message)
+    end
+  end
+end

data/spec/ruby_nos/list_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe RubyNos::List do
+  subject{List.new}
+  let(:element) {double("element", uuid: "12345")}
+
+  before do
+    subject.add(element)
+  end
+
+  describe "#add" do
+    it "adds an element to the list" do
+      expect(subject.list.count).to eq(1)
+      expect(subject.list.first).to eq({element.uuid => element})
+    end
+  end
+
+  describe "#update" do
+    let(:element_two) {double("another_element", uuid: "12345", some_other_thing: "something")}
+
+    it "updates an element on the list that has the same uuid" do
+      subject.update(element.uuid, element_two)
+      expect(subject.list.count).to eq 1
+      expect(subject.list.first[element_two.uuid].some_other_thing).to eq "something"
+    end
+  end
+
+  describe "#eliminate" do
+    it "eliminates an element from the list" do
+      subject.eliminate(element.uuid)
+      expect(subject.list.count).to eq 0
+    end
+  end
+
+  describe "#info_for" do
+    it "returns the information on the list for an element" do
+      info = subject.info_for(element.uuid)
+      expect(info.uuid).to eq("12345")
+    end
+  end
+
+  describe "#list_of_keys" do
+    it "returns the list of keys in the list" do
+      expect(subject.list_of_keys).to eq(["12345"])
+    end
+  end
+
+  describe "#is_on_the_list?" do
+    it "returns true if the element exists and folder if it does not exist" do
+      expect(subject.is_on_the_list?(element.uuid)).to eq(true)
+      expect(subject.is_on_the_list?("some_uuid")).to eq(false)
+    end
+  end
+end