xwot_discovery 0.0.1.pre → 0.1.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3a2e4b6563f09bf1c805ef4ed40247927bbe655
-  data.tar.gz: 97d7b15c289ff8852e5054f8c1744cf7f73fb3a4
+  metadata.gz: 8575eb9a35250840b1d4f04d3882f5dca531b916
+  data.tar.gz: b26d956d36f96ee6861b1ab424e14a76b61a4a6d
 SHA512:
-  metadata.gz: b9042015c1ba867a82e31b01d3f7ea3ca23fc671dc59f8f325d7623c0c29247cb10fe638fcdb1fcd9036e1e6f6c367fca358fba9fbe9338640b3c21f43792ef9
-  data.tar.gz: 9628ab43c008b504bf1bb2d8afd0ffdeb7530c34c8a83fe3fc265c6ffea092969a1b394db12fc13ed2c0cf9982fb95662aa22dd2d6763e65e029696a46868446
+  metadata.gz: 567f659c31ceb050ecf58145b8911d2b93ef81840de0c206e39166905e799c2a39573e6d90e97fafdfa06790044d5a2aadfe699ed206ffaa60a0718b70c4e86a
+  data.tar.gz: b2cf5a5a42e98ba5b09f65caf4212594a08de1d2a1f9bed6600529cf12e80bc6aea32ae4a44a8dd733dee8a9f24f1f9c5a491f453892f4fe916481bd3b738d87

data/example/client.rb

@@ -0,0 +1,28 @@
+require 'xwot_discovery'
+
+class MyListener < XwotDiscovery::BaseListener
+
+  def alive(message)
+    puts "received alive msg:\n"
+    mprint(message)
+  end
+
+  def bye(message)
+    puts "received bye msg:\n"
+    mprint(message)
+  end
+
+  def mprint(message)
+    m = ''
+    m += "\thostname: #{message.hostname}\n"
+    m += "\thost: #{message.host}\n"
+    m += "\tlocation: #{message.location}\n"
+    m += "\turn: #{message.urn}\n\n"
+    puts m
+  end
+
+end
+
+XwotDiscovery.service.register_listener(MyListener.new)
+
+loop { }

data/example/resource.rb

@@ -0,0 +1,34 @@
+require 'xwot_discovery'
+require 'sinatra'
+require 'socket'
+
+addr_info = Socket.ip_address_list.detect{|intf| intf.ipv4_private?}
+ip = addr_info.ip_address
+port = 4567
+a_hash = {
+  urn: 'urn:xwot:temperature-sensor',
+  location: "http://#{ip}:#{port}/temperature-sensor",
+  description: {
+    name: 'a temperature sensor',
+    room: 'blah blah'
+  },
+  interface: {
+    'http://10.0.0.33/temperature-sensor' => {
+      input: [],
+      output: [ :xml, :json, :html ],
+      method: :get,
+    }
+  }
+}
+
+resource = XwotDiscovery::XwotResource.new a_hash
+XwotDiscovery.service.register_resource(resource)
+
+set :bind, '0.0.0.0'
+get '/temperature-sensor' do
+  'hello world!'
+end
+
+get '/' do
+  'hello world'
+end

data/lib/xwot_discovery/message.rb

@@ -0,0 +1,21 @@
+module XwotDiscovery
+
+  class Message
+
+    attr_reader :method, :payload, :location,
+                :content_type, :protocol, :urn, :hostname, :host
+
+    def initialize(a_hash)
+      @method = a_hash[:method]
+      @location = a_hash[:location]
+      @content_type = a_hash[:content_type]
+      @payload = a_hash[:payload]
+      @protocol = a_hash[:protocol] || ''
+      @urn = a_hash[:urn]
+      @host = a_hash[:host]
+      @hostname = a_hash[:hostname]
+    end
+
+  end
+
+end

data/lib/xwot_discovery/protocol.rb

@@ -0,0 +1,149 @@
+module XwotDiscovery
+
+  #
+  # An interface for a discovery protocol.
+  #
+  class Protocol
+
+    def listen
+      raise 'not implemented!'
+    end
+
+    def close
+      raise 'not implemented!'
+    end
+
+    def send(message)
+      raise 'not implemented!'
+    end
+
+    def receive
+      raise 'not implemented!'
+    end
+
+    def notify_me(subject)
+      raise 'not implemented!'
+    end
+
+  end
+
+  #
+  # Prototype: The Xwot Protocol Discovery implements the protocol interface.
+  #
+  class XwotProtocol < Protocol
+
+    TTL = 1 # time-to-live
+    MULTICAST_ADDR = "224.0.0.15" # multicast group
+    BIND_ADDR = "0.0.0.0"
+    PORT = 2015
+
+    NAME = "XWOT-DISCOVERY"
+    VERSION = "1.0"
+    CRLN = "\r\n"
+    FLAGS = 0
+
+    RECEIVE_MAX_BYTES = 256
+
+    def initialize
+      @socket = nil
+      @observer = nil
+    end
+
+    def listen
+      init
+      Thread.new do
+        loop do
+          Thread.start(receive) do |data|
+            lines = data.split(CRLN)
+            msg_hash = parse(lines)
+            message = Message.new(msg_hash)
+            #puts "#{Thread.current} - #{msg_hash}\n"
+            @observer.dispatch(message)
+          end
+        end
+      end
+    end
+
+    def parse(lines)
+      msg_hash = {
+        method: '',
+        protocol: '',
+        urn: '*',
+        payload: []
+      }
+
+      payload = false
+      lines.each_with_index do |line, index|
+        if index == 0
+          method, urn, protocol = line.split(' ')
+          msg_hash[:method] = method
+          msg_hash[:protocol] = protocol
+          msg_hash[:urn] = urn
+        elsif payload
+          msg_hash[:payload] ||= []
+          msg_hash[:payload] << line
+        elsif !line.empty?
+          header_field, header_value = line.split(' ')
+          header_field = header_field[0...-1].downcase.tr('-','_').to_sym
+          msg_hash[header_field] = header_value
+        elsif line.empty?
+          payload = true
+        end
+      end
+      msg_hash[:payload] = msg_hash[:payload].join('')
+      msg_hash
+    end
+
+    def close
+      @socket.close if !@socket.nil?
+    end
+
+    def send(message)
+      client_socket = UDPSocket.open
+      client_socket.setsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL, TTL)
+
+      urn = if message.urn.nil?
+        '*'
+      else
+        message.urn
+      end
+
+      msg = ""
+      msg += "#{message.method} #{urn} #{NAME}/#{VERSION}#{CRLN}"
+      msg += "HOST: #{MULTICAST_ADDR}:#{PORT}#{CRLN}"
+      msg += "HOSTNAME: #{Socket.gethostname}#{CRLN}"
+
+      if ['alive', 'bye', 'update'].include?(message.method)
+        msg += "LOCATION: #{message.location}#{CRLN}"
+        msg += "CONTENT-TYPE: #{message.content_type}#{CRLN}"
+        msg += "#{CRLN}"
+        msg += "#{message.payload}#{CRLN}"
+      end
+
+      msg += "#{CRLN}"
+      client_socket.send(msg, FLAGS, MULTICAST_ADDR, PORT)
+      client_socket.close
+    end
+
+    def receive
+      data, _ = @socket.recvfrom(RECEIVE_MAX_BYTES)
+      data
+    end
+
+    def notify_me(subject)
+      @observer = subject
+    end
+
+    private
+
+    def init
+      @socket = UDPSocket.new(Socket::AF_INET)
+      membership  = IPAddr.new(MULTICAST_ADDR).hton + IPAddr.new(BIND_ADDR).hton
+      @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+      @socket.bind(BIND_ADDR, PORT)
+    end
+
+  end
+
+end

data/lib/xwot_discovery/resource.rb

@@ -0,0 +1,20 @@
+module XwotDiscovery
+
+  class XwotResource
+
+    attr_reader :description, :urn, :interface, :location
+
+    def initialize(a_hash)
+      @urn = a_hash[:urn]
+      @location = a_hash[:location]
+      @interface = a_hash[:interface]
+      @description = a_hash[:description]
+    end
+
+    def payload
+      JSON.generate(@description)
+    end
+
+  end
+
+end

data/lib/xwot_discovery/service.rb

@@ -0,0 +1,102 @@
+module XwotDiscovery
+
+  class XwotService
+
+    ALIVE_INTERVAL_SECONDS = 60
+
+    class ServiceProtocolListener < BaseListener
+
+      def initialize(service, resources)
+        @service = service
+        @resources = resources
+      end
+
+      def alive(message)
+        remove = []
+        @service.find_callbacks.each do |tuple|
+          urn, callback = tuple
+          if urn == message.urn
+            callback.call(message)
+            remove << tuple
+          end
+        end
+        @service.find_callbacks = @service.find_callbacks - remove
+      end
+
+      def find(message, service)
+        if message.urn == '*'
+          @resources.each { |resource| @service.send_alive(resource) }
+        else
+          filtered = @resources.select { |resource| resource.urn == message.urn }
+          filtered.each { |resource| @service.send_alive(resource) }
+        end
+      end
+
+    end
+
+    attr_accessor :find_callbacks
+
+    def initialize(service_protocol)
+      @service_protocol = service_protocol
+      @resources = []
+      @rand = rand * 2 * 60
+      @find_callbacks = []
+      listener = ServiceProtocolListener.new(self, @resources)
+      @service_protocol.register_listener(listener)
+    end
+
+    def start
+      @service_protocol.start
+      #p @rand
+      Thread.new do
+        sleep @rand
+        loop do
+          @resources.each { |resource| send_alive(resource) }
+          sleep ALIVE_INTERVAL_SECONDS
+        end
+      end
+    end
+
+    def find(urn = '*', &block)
+      if block_given?
+        @find_callbacks << [urn, block]
+      end
+      @service_protocol.find(urn)
+    end
+
+    def register_resource(resource)
+      @resources << resource
+      send_alive(resource)
+    end
+
+    def unregister_resource(resource)
+      @resources.delete(resource)
+      send_bye(resource)
+    end
+
+    def register_listener(listener)
+      @service_protocol.register_listener(listener)
+    end
+
+    def unregister_listener(listener)
+      @service_protocol.unregister_listener(listener)
+    end
+
+
+    def send_alive(resource)
+      2.times do
+        @service_protocol.alive(resource)
+        sleep 0.5
+      end
+    end
+
+    def send_bye(resource)
+      2.times do
+        @service_protocol.bye(resource)
+        sleep 0.5
+      end
+    end
+
+  end
+
+end

data/lib/xwot_discovery/service_listener.rb

@@ -0,0 +1,44 @@
+module XwotDiscovery
+
+  class ServiceListener
+
+    def alive(message)
+      raise 'not implemented!'
+    end
+
+    def find(message, service = nil)
+      raise 'not implemented!'
+    end
+
+    def bye(message)
+      raise 'not implemented!'
+    end
+
+    def update(message)
+      raise 'not implemented!'
+    end
+
+  end
+
+
+  class BaseListener < ServiceListener
+
+    def alive(message)
+      # do nothing
+    end
+
+    def find(message, service = nil)
+      # do nothing
+    end
+
+    def bye(message)
+      # do nothing
+    end
+
+    def update(message)
+      # do nothing
+    end
+
+  end
+
+end

data/lib/xwot_discovery/service_protocol.rb

@@ -0,0 +1,124 @@
+module XwotDiscovery
+
+  class XwotServiceProtocol
+
+    class Registry
+
+      def initialize
+        @registry = {}
+      end
+
+      def add(message)
+        @registry[message.location] ||= {
+          uri: message.location,
+          message: message
+        }
+      end
+
+      def update(message)
+        @registry[message.location] = {
+          uri: message.location,
+          message: message
+        }
+      end
+
+      def remove(message)
+        @registry.delete(message.location)
+      end
+
+    end
+
+    def initialize(protocol)
+      @protocol = protocol
+      @listeners = []
+      @find_callbacks = []
+      @registry = Registry.new
+      @protocol.notify_me(self)
+    end
+
+    def start
+      @protocol.listen
+    end
+
+    def shutdown
+      @protocol.close
+    end
+
+    def register_listener(listener)
+      @listeners << listener
+    end
+
+    def unregister_listener(listener)
+      @listeners.delete(listener)
+    end
+
+    def dispatch(message)
+      @listeners.each do |listener|
+        case message.method.downcase
+        when 'alive'
+          @registry.add(message)
+          listener.alive(message)
+        when 'update'
+          @registry.update(message)
+          listener.update(message)
+        when 'find'
+          listener.find(message, self)
+        when 'bye'
+          @registry.remove(message)
+          listener.bye(message)
+        else
+          # do nothing
+        end
+      end
+    end
+
+    def find(urn = '')
+      urn_str = case urn.to_s
+      when '*'
+        '*'
+      when ''
+        '*'
+      else
+        urn
+      end
+      # TODO: registry lookup
+      message = Message.new({
+        method: 'find',
+        urn: urn_str})
+      #p message
+      @protocol.send(message)
+    end
+
+    def alive(resource)
+      message = Message.new({
+        method: 'alive',
+        urn: resource.urn,
+        location: resource.location,
+        content_type: 'application/json',
+        payload: resource.payload})
+      @protocol.send(message)
+    end
+
+    def bye(resource)
+      message = Message.new({
+        method: 'bye',
+        urn: resource.urn,
+        location: resource.location,
+        content_type: 'application/json',
+        payload: resource.payload})
+      @protocol.send(message)
+    end
+
+    def update(resource)
+      message = Message.new({
+        method: 'update',
+        urn: resource.urn,
+        location: resource.location,
+        content_type: 'application/json',
+        payload: resource.payload})
+      @protocol.send(message)
+    end
+
+  end
+
+end

data/lib/xwot_discovery/version.rb

@@ -1,3 +1,3 @@
 module XwotDiscovery
-  VERSION = "0.0.1.pre"
+  VERSION = "0.1.0.pre"
 end

data/lib/xwot_discovery.rb

@@ -1,5 +1,34 @@
-require "xwot_discovery/version"
+require 'socket'
+require 'ipaddr'
+require 'json'
+
+require 'xwot_discovery/version'
+require 'xwot_discovery/message'
+require 'xwot_discovery/protocol'
+require 'xwot_discovery/service_listener'
+require 'xwot_discovery/service_protocol'
+require 'xwot_discovery/service'
+require 'xwot_discovery/resource'
+
 
 module XwotDiscovery
-  # Your code goes here...
+
+  def self.service
+    if @service.nil?
+      init
+      @service.start
+      @service
+    else
+      @service
+    end
+  end
+
+  private
+
+  def self.init
+    @protocol ||=  XwotProtocol.new
+    @service_protocol ||= XwotServiceProtocol.new(@protocol)
+    @service ||= XwotService.new @service_protocol
+  end
+
 end

data/spec/discovery_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module XwotDiscovery
+
+  class MyListener < BaseListener
+
+    def alive(message)
+      #p 'alive received!!'
+      #p message
+    end
+
+    def find(message, service)
+      #p 'find received!!'
+      #p message
+    end
+
+  end
+
+  describe "XwotDiscovery.service" do
+
+    before do
+      @a_hash = {
+        urn: 'urn:xwot:temperature-sensor',
+        location: 'http://10.0.0.33/temperature-sensor',
+        description: {
+          name: 'a temperature sensor',
+          room: 'blah blah'
+        },
+        interface: {
+          'http://10.0.0.33/temperature-sensor' => {
+            input: [],
+            output: [ :xml, :json, :html ],
+            method: :get,
+          }
+        }
+      }
+      @resource =  XwotResource.new @a_hash
+      s = XwotDiscovery.service
+      s.register_listener(MyListener.new)
+    end
+
+    it "#register_device" do
+      s = XwotDiscovery.service
+      s.register_resource(@resource)
+      #sleep 120 * 2
+    end
+
+    it "#find" do
+      s = XwotDiscovery.service
+      s.find 'urn:xwot:temperature-sensor'
+      s.find
+
+      s.find 'urn:xwot:temperature-sensor' do |message|
+        p 'callback!!'
+        p message.urn
+      end
+      sleep 120 * 2
+    end
+
+  end
+
+
+end

data/spec/resource_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module XwotDiscovery
+
+  describe XwotResource do
+
+    before do
+      @a_hash = {
+        urn: 'urn:xwot:temperature-sensor',
+        location: 'http://10.0.0.33/temperature-sensor',
+        description: {
+          name: 'a temperature sensor',
+          room: 'blah blah'
+        },
+        interface: {
+          'http://10.0.0.33/temperature-sensor' => {
+            input: [],
+            output: [ :xml, :json, :html ],
+            method: :get,
+          }
+        }
+      }
+    end
+
+    it ".new" do
+      res = XwotResource.new @a_hash
+      expect(res.urn).to_not be_nil
+      expect(res.location).to_not be_nil
+      expect(res.description).to_not be_nil
+      expect(res.interface).to_not be_nil
+    end
+
+  end
+
+
+end

data/spec/service_protocol_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+module XwotDiscovery
+
+  #
+  # The MockProtocol implements a mock discovery protocol.
+  # It's used to test the main protocol logic of the service protocol.
+  #
+  class MockProtocol < Protocol
+
+    def listen
+      p 'listen'
+      receive
+    end
+
+    def close
+      p 'close'
+    end
+
+    def send(message)
+      p 'send'
+      p message
+    end
+
+    def receive
+      p 'receive'
+      message = Message.new(method: 'alive',
+      host: '224.0.0.15:2015',
+      content_type: 'application/json',
+      payload: '{ "property": "value" }',
+      location: 'http://10.0.0.26/test')
+      @observer.dispatch(message)
+    end
+
+    def notify_me(subject)
+      p 'notify_me called'
+      @observer = subject
+    end
+
+  end
+
+  class MockListener < ServiceListener
+
+    def alive(message)
+      p message
+      p 'alive method called'
+    end
+
+    def find(message, service)
+      p message
+      p 'find method called'
+    end
+
+    def bye(message)
+      p message
+      p 'bye method called'
+    end
+
+    def update(message)
+      p message
+      p 'update method called'
+    end
+
+  end
+
+  describe XwotServiceProtocol do
+    before do
+      @protocol =  XwotProtocol.new
+      @service_protocol = XwotServiceProtocol.new(@protocol)
+    end
+
+    describe "#start" do
+      it "starts the service" do
+        @service_protocol.start
+      end
+    end
+
+    describe "#register" do
+
+      it "handles an incoming message" do
+        @service_protocol.register_listener(MockListener.new)
+        @protocol.listen
+        message = Message.new(
+          method: 'alive',
+          content_type: 'application/json',
+          payload: '{ "property": "value" }',
+          location: 'http://10.0.0.26/test'
+        )
+        @protocol.send(message)
+        @service_protocol.find
+        loop do
+
+        end
+      end
+
+    end
+
+    describe "#shutdown" do
+      it "shuts down the service" do
+        @service.shutdown
+      end
+    end
+
+  end
+
+end

data/spec/service_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module XwotDiscovery
+
+  class MyListener < BaseListener
+
+    def alive(message)
+      p 'alive received!!'
+      p message
+    end
+
+  end
+
+  describe XwotService do
+
+    before do
+      @a_hash = {
+        urn: 'urn:xwot:temperature-sensor',
+        location: 'http://10.0.0.33/temperature-sensor',
+        description: {
+          name: 'a temperature sensor',
+          room: 'blah blah'
+        },
+        interface: {
+          'http://10.0.0.33/temperature-sensor' => {
+            input: [],
+            output: [ :xml, :json, :html ],
+            method: :get,
+          }
+        }
+      }
+      @resource =  XwotResource.new @a_hash
+      @protocol =  XwotProtocol.new
+      @service_protocol = XwotServiceProtocol.new(@protocol)
+      @service = XwotService.new @service_protocol
+      @service.register_listener(MyListener.new)
+    end
+
+    it "#register_device" do
+      @service.register_resource(@resource)
+      @service.start
+      loop do
+
+      end
+    end
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'pp'
+require 'xwot_discovery'

data/xwot_discovery.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xwot_discovery
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.1.0.pre
 platform: ruby
 authors:
 - Alexander Rueedlinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-08 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Discovery for the xWoT
 email:
 - a.rueedlinger@gmail.com
@@ -50,8 +64,22 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- example/client.rb
+- example/resource.rb
 - lib/xwot_discovery.rb
+- lib/xwot_discovery/message.rb
+- lib/xwot_discovery/protocol.rb
+- lib/xwot_discovery/resource.rb
+- lib/xwot_discovery/service.rb
+- lib/xwot_discovery/service_listener.rb
+- lib/xwot_discovery/service_protocol.rb
 - lib/xwot_discovery/version.rb
+- spec/discovery_spec.rb
+- spec/resource_spec.rb
+- spec/service_protocol_spec.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
+- xwot_discovery-0.0.1.pre.gem
 - xwot_discovery.gemspec
 homepage: https://github.com/lexruee/xwot-discovery-ruby
 licenses:
@@ -73,8 +101,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Discovery for the xWoT
-test_files: []
+test_files:
+- spec/discovery_spec.rb
+- spec/resource_spec.rb
+- spec/service_protocol_spec.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
+has_rdoc: