coap 0.0.16 → 0.1.0

data/lib/core/coap/types.rb

@@ -0,0 +1,69 @@
+module CoRE
+  module CoAP
+    module Types
+      # Arrays that describe a specific option type:
+      # [default value, length range, repeatable?, decoder, encoder]
+
+      # We only care about presence or absence, always empty.
+      def presence_once
+        [false, (0..0), false, ->(a) { true }, ->(v) { v ? [''] : []}]
+      end
+
+      # Token-style, goedelized in o256.
+      def o256_once(min, max, default = nil)
+        [default, (min..max), false,
+         ->(a) { CoAP.o256_decode(a[0]) },
+         ->(v) { v == default ? [] : [CoAP.o256_encode(v)] }
+        ]
+      end
+
+      # Unused, for now.
+      def o256_many(min, max)
+        [nil, (min..max), true,
+         ->(a) { a.map{ |x| CoAP.o256_decode(x)} },
+         ->(v) { Array(v).map{ |x| CoAP.o256_encode(x)} }
+        ]
+      end
+
+      # vlb as in core-coap Annex A
+      def uint_once(min, max, default = nil)
+        [default, (min..max), false,
+         ->(a) { CoAP.vlb_decode(a[0]) },
+         ->(v) { v == default ? [] : [CoAP.vlb_encode(v)] }
+        ]
+      end
+
+      def uint_many(min, max)
+        [nil, (min..max), true,
+         ->(a) { a.map{ |x| CoAP.vlb_decode(x)} },
+         ->(v) { Array(v).map{ |x| CoAP.vlb_encode(x)} }
+        ]
+      end
+
+      # Any other opaque byte sequence (once).
+      def opaq_once(min, max, default = nil)
+        [default, (min..max), false,
+         ->(a) { a[0] },
+         ->(v) { v == default ? [] : Array(v) }
+        ]
+      end
+
+      # Any other opaque byte sequence (many).
+      def opaq_many(min, max)
+        [nil, (min..max), true, ->(a) { a }, ->(v) { Array(v) }]
+      end
+
+      # Same, but interpreted as UTF-8
+      def str_once(min, max, default = nil)
+        [default, (min..max), false,
+          ->(a) { a[0] },
+          ->(v) { v == default ? [] : Array(v) }
+        ]
+      end
+
+      def str_many(min, max)
+        [nil, (min..max), true, ->(a) { a }, ->(v) { Array(v) }]
+      end
+    end
+  end
+end

data/lib/core/coap/utility.rb

@@ -0,0 +1,34 @@
+module CoRE
+  module CoAP
+    module Utility
+      def empty_buffer
+        String.new # Was: ''.encode(BIN)
+      end
+
+      def invert_into_hash(a)
+        a.each_with_index.each_with_object({}) { |k, h| h[k[0]] = k[1] if k[0] }
+      end
+
+      def critical?(option)
+        if oi = CoAP::OPTIONS_I[option] # this is really an option name symbol
+          option = oi[0]          # -> to option number
+        end
+        option.odd?
+      end
+
+      def unsafe?(option)
+        if oi = CoAP::OPTIONS_I[option] # this is really an option name symbol
+          option = oi[0]          # -> to option number
+        end
+        option & 2 == 2
+      end
+
+      def no_cache_key?(option)
+        if oi = CoAP::OPTIONS_I[option] # this is really an option name symbol
+          option = oi[0]          # -> to option number
+        end
+        option & 0x1e == 0x1c
+      end
+    end
+  end
+end

data/lib/core/coap/version.rb

@@ -0,0 +1,5 @@
+module CoRE
+  module CoAP
+    VERSION = '0.1.0'
+  end
+end

data/lib/core/core_ext/socket.rb

@@ -0,0 +1,19 @@
+class Socket
+  def self.if_nametoindex(name)
+    ifaddr_by_name(name).ifindex
+  rescue NoMethodError
+    0
+  end
+
+  def self.if_up?(name)
+    ifaddr_by_name(name).flags & Socket::IFF_UP == 1
+  rescue NoMethodError
+    false
+  end
+
+  private
+
+  def self.ifaddr_by_name(name)
+    Socket.getifaddrs.select { |x| x.name == name }.first
+  end
+end

data/lib/core/hexdump.rb

@@ -0,0 +1,18 @@
+# hexdump.rb
+# Copyright (C) 2010..2013 Carsten Bormann <cabo@tzi.org>
+
+class String
+  def hexdump(prefix = '', prepend_newline = true)
+    a, i = [], 0
+    a << '' if prepend_newline
+    while i < length
+      slice = self.byteslice(i, 16)
+      a << '%s%-48s |%-16s|' %
+        [prefix,
+         slice.bytes.map { |b| '%02x' % b.ord }.join(' '),
+         slice.gsub(/[^ -~]/mn, ".")]
+      i += 16
+    end
+    a.join("\n")
+  end
+end

data/lib/core/link.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module CoRE
+  # Implements CoRE Link Format (RFC6690)
+  # http://tools.ietf.org/html/rfc6690
+  # TODO Handle repeated attributes
+  class Link
+    VALID_ATTRS = [
+      :anchor, :ct, :exp, :hreflang, :if, :ins, :media, :obs, :rt, :rel, :rev,
+      :sz, :title, :type
+    ]
+
+    attr_accessor :uri
+    attr_reader :attrs
+
+    def initialize(uri, attrs = {})
+      @uri = uri || raise(ArgumentError.new('URI can not be unset.'))
+      @attrs = attrs
+
+      validate_attrs!(@attrs)
+    end
+
+    def merge!(hash)
+      a = @attrs.merge(hash)
+      validate_attrs!(a)
+      @attrs = a
+    end
+
+    def method_missing(symbol, *args)
+      attr = symbol.to_s.delete('=').to_sym
+
+      if !VALID_ATTRS.include?(attr)
+        raise ArgumentError.new("Invalid attribute «#{attr}».")
+      end
+
+      if symbol[-1] == '='
+        @attrs[attr] = args.first.to_s
+      else
+        @attrs[attr]
+      end
+    end
+
+    def to_s
+      s = "<#{@uri}>"
+
+      @attrs.sort.each do |attr, value|
+        s += ";#{attr}=\"#{value}\""
+      end
+
+      s
+    end
+
+    def self.parse(data)
+      parts = data.split(';')
+
+      uri = parts.shift
+      uri = uri.match(/\A\<(.+)\>\z/)
+
+      if uri.nil?
+        raise ArgumentError.new("Invalid URI in '#{data}'.")
+      end
+
+      link = Link.new(uri[1])
+
+      parts.each do |part|
+        attr, value = part.split('=')
+
+        attr  = (attr + '=').to_sym
+        value = value.delete('"') unless value.nil?
+
+        link.send(attr, value)
+      end
+
+      link
+    end
+
+    # TODO Handle misplaced commas
+    def self.parse_multiple(data)
+      results = []
+
+      data.split(',').each do |part|
+        results << self.parse(part)
+      end
+
+      results
+    end
+
+    private
+
+    def validate_attrs!(attrs)
+      if (VALID_ATTRS | attrs.keys).size > VALID_ATTRS.size
+        invalid = (VALID_ATTRS | attrs.keys) - VALID_ATTRS
+        raise ArgumentError.new("Invalid attributes: #{invalid.join(', ')}.")
+      end
+    end
+  end
+end

data/lib/core/os.rb

@@ -0,0 +1,15 @@
+module CoRE
+  module OS
+    def self.linux?
+      @@linux ||= !!(os =~ /^linux/)
+    end
+
+    def self.os
+      RbConfig::CONFIG['host_os']
+    end
+
+    def self.osx?
+      @@osx ||= !!(os =~ /^darwin/)
+    end
+  end
+end

data/spec/block_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'benchmark'
+
+describe Block do
+  subject { Block.new(0, false, 16) }
+  let(:data1) { '+' * 42 }
+  let(:data2) { '+' * 32 }
+
+  describe '#chunk' do
+    it 'should return chunks' do
+      a = [0, 1, 2, 3].map do |i|
+        subject.num = i
+        subject.chunk(data1)
+      end
+
+      expect(a).to eq(['+' * 16, '+' * 16, '+' * 10, nil])
+    end
+  end
+
+  describe '#chunk_count' do
+    it 'should return correct count' do
+      expect(subject.chunk_count(data1)).to eq(3)
+      expect(subject.chunk_count(data2)).to eq(2)
+    end
+  end
+  
+  describe '#included_by?' do
+    it 'should return true if body empty and index 0' do
+      expect(subject.included_by?('')).to be(true)
+      expect(subject.included_by?(nil)).to be(true)
+    end
+
+    it 'should return false if body empty and index > 0' do
+      subject.num = 1
+      expect(subject.included_by?('')).to be(false)
+      expect(subject.included_by?(nil)).to be(false)
+    end
+
+    it 'should return true if chunk index exists' do
+      [0, 1, 2].each do |num|
+        subject.num = num
+        expect(subject.included_by?(data1)).to be(true)
+      end
+
+      [0, 1].each do |num|
+        subject.num = num
+        expect(subject.included_by?(data2)).to be(true)
+      end
+    end
+
+    it 'should return false if chunk index does not exists' do
+      [3, 4, 5].each do |num|
+        subject.num = num
+        expect(subject.included_by?(data1)).to be(false)
+      end
+
+      [2, 3].each do |num|
+        subject.num = num
+        expect(subject.included_by?(data2)).to be(false)
+      end
+    end
+  end
+
+  describe '#last?' do
+    it 'should return false unless last chunk' do
+      [0, 1, 3].each do |num|
+        subject.num = num
+        expect(subject.last?(data1)).to be(false)
+      end
+
+      [0, 2, 3].each do |num|
+        subject.num = num
+        expect(subject.last?(data2)).to be(false)
+      end
+
+      [0, 1, 2].each do |num|
+        subject.num = num
+        expect(subject.last?('')).to be(true)
+        expect(subject.last?(nil)).to be(true)
+      end
+    end
+
+    it 'should return true if last chunk' do
+      subject.num = 2
+      expect(subject.last?(data1)).to be(true)
+
+      subject.num = 1
+      expect(subject.last?(data2)).to be(true)
+    end
+  end
+
+  describe '#more?' do
+    it 'should return true unless last chunk or bigger' do
+      [0, 1].each do |num|
+        subject.num = num
+        expect(subject.more?(data1)).to be(true)
+      end
+
+      [2, 3].each do |num|
+        subject.num = num
+        expect(subject.more?(data1)).to be(false)
+      end
+
+      [0].each do |num|
+        subject.num = num
+        expect(subject.more?(data2)).to be(true)
+      end
+
+      [1, 2].each do |num|
+        subject.num = num
+        expect(subject.more?(data2)).to be(false)
+      end
+
+      [0, 1, 2].each do |num|
+        subject.num = num
+        expect(subject.more?('')).to be(false)
+        expect(subject.more?(nil)).to be(false)
+      end
+    end
+  end
+
+  describe '#encode' do
+    it 'should work with examples' do
+      expect(subject.encode).to eq(0)
+
+      block = Block.new(0, true, 16)
+      expect(block.encode).to eq(8)
+
+      (1..6).each do |i|
+        block = Block.new(0, false, 2**(i+4))
+        expect(block.encode).to eq(i)
+      end
+    end
+  end
+
+  describe '#encode and #decode' do
+    it 'should be reversible (encode -> decode)' do
+      num = rand(Block::MAX_NUM + 1)
+      more = [true, false].sample
+      size = Block::VALID_SIZE.sample
+
+      a = Block.new(num, more, size).encode
+      b = Block.new(a).decode
+
+      expect(b.num).to  eq(num)
+      expect(b.more).to eq(more)
+      expect(b.size).to eq(size)
+    end
+
+    it 'should be reversible (decode -> encode)' do
+      i = 7
+      i = rand(2**24) until (i & 7) != 7
+
+      a = Block.new(i).decode
+      b = Block.new(a.num, a.more, a.size).encode
+
+      expect(b).to eq(i)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Client do
+  subject { Client.new }
+
+  describe '#get' do
+    describe 'with separated answer' do
+      it 'should return correct mcode and payload' do
+        answer = subject.get('/separate', 'coap.me')
+        expect(answer.mcode).to eq([2, 5])
+        expect(answer.payload).to eq('That took a long time')
+      end
+    end
+  end
+
+  describe 'modifying methods' do
+    subject { Client.new(max_payload: 512) }
+    let(:payload) { Faker::Lorem.paragraphs(5).join("\n") }
+    let(:payload_utf8) { '♥' + payload }
+
+    describe '#post' do
+      describe 'with block1 option' do
+        describe 'creating resource' do
+          it 'should work with ASCII payload' do
+            answer = subject.post('/large-create', 'coap.me', nil, payload)
+            expect(answer.mcode).to eq([2, 1])
+
+            answer = subject.get('/large-create', 'coap.me')
+            expect(answer.mcode).to eq([2, 5])
+            expect(answer.payload).to eq(payload)
+          end
+
+          it 'should work with UTF8 payload' do
+            answer = subject.post('/large-create', 'coap.me', nil, payload_utf8)
+            expect(answer.mcode).to eq([2, 1])
+
+            answer = subject.get('/large-create', 'coap.me')
+            expect(answer.mcode).to eq([2, 5])
+            expect(answer.payload.force_encoding('utf-8')).to eq(payload_utf8)
+          end
+        end
+      end
+    end
+
+    describe '#put' do
+      describe 'with block1 option' do
+        describe 'updating resource' do
+          it 'should work with ASCII payload' do
+            answer = subject.put('/large-update', 'coap.me', nil, payload)
+            expect(answer.mcode).to eq([2, 4])
+
+            answer = subject.get('/large-update', 'coap.me')
+            expect(answer.mcode).to eq([2, 5])
+            expect(answer.payload).to eq(payload)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#observe' do
+    before do
+      @answers = []
+
+      @t1 = Thread.start do
+        subject.observe \
+          '/obs', 'vs0.inf.ethz.ch', nil,
+          ->(s, m) { @answers << m }
+      end
+
+      Timeout.timeout(12) do
+        sleep 0.25 while !(@answers.size > 2)
+      end
+    end
+
+    it 'should receive updates' do
+      expect(@answers.size).to be > 2
+    end
+
+    after do
+      @t1.kill
+    end
+  end
+end