loriot-rb 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d99af5c1b764bdb03d3249026d43675062b689a2
+  data.tar.gz: 8720cbe04f7b6074bb6461673f1836e1a2d8030d
+SHA512:
+  metadata.gz: f328d76dcf62f672180aac284d8d8cdc09dbe17c024efde88c5c353f7516e2338fd028aab0d0d4fecca03626b2986682487708feea4ed56a9e8ba607051a062e
+  data.tar.gz: 555cc19bf453f9ec5d1338bc1014a92bb43831a90d8c4bec1b0fd37bcb2b9432781e57546cc1798ac9e709c45a2e602103c20af11bcb33a852e486c066469cdf

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+v0.4.0 [☰](https://bitbucket.org/fractalgarden/loriot-rb/branches/compare/v0.3.0..v0.4.0) April 7th, 2017
+------------------------------
+* the method `listen` now accept a block to do something every iteration, moreover, it has been included in the unit test.
+
+v0.3.0 April 7th, 2017
+------------------------------
+* added the configuration in the config.rb 
+* moved sensible data to a yaml accessible dinamically with LoriotRb::Settings 
+* added a rails generator
+* improved the code organization
+* improved the readme
+
+v0.2.0 April 5th, 2017
+------------------------------
+* dividing the project into modules based on the connection protocol
+* new method listen to waiting for data
+* improved debug option
+
+v0.1.0 March 10th, 2017
+------------------------------
+* Starting project
+* Connection with tls
+* Basic unit test

data/LICENSE

@@ -0,0 +1,15 @@
+LoriotRb
+
+Copyright (C) 2017  Marco Mastrodonato, marco.mastrodonato@fractalgarden.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -0,0 +1,140 @@
+# IOT at you service with LoraWan and Ruby
+### Manage your devices with Loriot cloud system
+
+[![Version     ](https://badge.fury.io/rb/loriot-rb.svg)                        ](https://rubygems.org/gems/loriot-rb)
+[![Travis CI   ](http://img.shields.io/travis/marcomd/loriot-rb/master.svg)     ](https://travis-ci.org/marcomd/loriot-rb)
+[![Quality     ](http://img.shields.io/codeclimate/github/marcomd/loriot-rb.svg)](https://codeclimate.com/github/marcomd/loriot-rb)
+
+### What is Lora?
+
+LoRaWAN is a Low Power Wide Area Network with features that support low-cost, mobile, and secure bi-directional communication for Internet of Things (IoT), machine-to-machine (M2M), and smart city, and industrial applications. LoRaWAN is optimized for low power consumption and is designed to support large networks with millions and millions of devices. Innovative features of LoRaWAN include support for redundant operation, geolocation, low-cost, and low-power - devices can even run on energy harvesting technologies enabling the mobility and ease of use of Internet of Things.
+
+
+![](/assets/LoraWan_Description.jpg)
+
+
+## Install
+
+    gem install loriot-rb
+
+To use it in a bundle, add to gem file `gem 'loriot-rb'` and run `bundle install`
+
+## Connection to loriot server
+
+Establish a secure connection to your `Loriot Application` on the cloud.
+
+This version only support the TLS protocol.
+
+From irb require the library:
+
+```ruby
+require 'loriot-rb'
+```
+
+then create an instance
+
+```ruby
+lora = LoriotClient.new
+```
+
+if you are in debug mode you should also receive a json:
+
+```json
+{ "hello":"LORIOT.io TLS Server", "version":"1.0.4" }
+```
+
+### Send data to a device
+
+
+```ruby
+lora.send_cmd(EUI: 'Insert here your EUI code', confirmed: true, data: "0101")
+```
+
+Request example:
+
+```json
+{ "cmd":"tx", "EUI":"BE7A0000000010B7", "port":40, "confirmed":false, "data":"0101" }
+```
+
+Response example:
+
+```json
+{ "cmd":"txd", "EUI":"BE7A0000000010B7", "seqdn":114, "seqq":113, "ts":1489133179385 }
+```
+
+`"cmd":"txd"` show the data sent to the gateway
+
+The response could also be:
+
+```json
+{ "cmd":"tx", "EUI":"BE7A0000000010CF", "seqdn": 4, "data": "0301", "success": "Data enqueued" }
+```
+
+### Receive Data
+
+To listen your devices:
+
+```ruby
+lora.listen
+```
+
+### Close the connection
+
+```ruby
+lora.quit
+```
+
+## Compatibility
+
+Ruby `2.3+`
+
+## Install
+
+    gem install loriot-rb
+
+To use it in a bundle, add to gem file `gem 'loriot-rb'` and run `bundle install`
+
+## To Do
+
+- [x] Connect to a device with tls protocol `v0.1.0`
+- [x] Send data to a device `v0.1.0`
+- [x] Receive data from a device `v0.2.0`
+- [x] Organization in modules to support new protocols  `v0.2.0`
+- [x] Add a configuration `v0.3.0`
+- [x] Add a rails generator `v0.3.0`
+- [ ] Test with many devices
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-feature`)
+3. Commit your changes (`git commit -am 'I made extensive use of all my creativity'`)
+4. Push to the branch (`git push origin my-feature`)
+5. Create new Pull Request
+
+## Testing
+
+Wide coverage with `xx unit tests` and `xxx assertions`
+
+To test locally install the development requirements:
+
+    bundle install
+
+Then execute:
+
+    bundle exec ruby test/unit_test.rb
+
+Performance tests:
+
+    bundle exec ruby test/performance_test.rb
+
+
+## Found a bug?
+
+Please open an issue.
+
+
+## License
+
+The GNU Lesser General Public License, version 3.0 (LGPL-3.0)
+See LICENSE file

data/lib/config/config.rb

@@ -0,0 +1,6 @@
+LoriotRb.configure do |config|
+  # These informations are shared for all environments
+  config.protocol = :tls
+  config.host = 'eu1.loriot.io'
+  config.port = 737
+end

data/lib/config/private.yml

@@ -0,0 +1,17 @@
+defaults: &defaults
+  appid: "BE7A02C1"
+  token: "zHcD-1ouz3ytyOLE6SMhwA"
+  test_eui: "BE7A0000000010CF"
+  #foo: add every variable you need and use it with => LoriotRb::Settings.foo
+  #  bar: sub variable are accessible with hash => LoriotRb::Settings.foo[:bar]
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults
+  appid: "YOUR PRODUCTION APP ID"
+  token: "YOUR PRODUCTION TOKEN"

data/lib/config/private_EXAMPLE.yml

@@ -0,0 +1,19 @@
+defaults: &defaults
+  # Insert your credentials provided by Loriot
+  appid:
+  token:
+  # Insert your device for test purpose
+  test_eui:
+  #foo: add every variable you need and use it with => LoriotRb::Settings.foo
+  #  bar: sub variable are accessible with hash => LoriotRb::Settings.foo[:bar]
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults
+  appid:
+  token:

data/lib/core/configuration.rb

@@ -0,0 +1,27 @@
+module LoriotRb
+  class Configuration
+    # attr_writer :allow_sign_up
+
+    attr_accessor :protocol, :host, :port, :env
+
+    def initialize
+      @protocol = nil
+      @host = nil
+      @port = nil
+      @env = 'development'
+    end
+
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/core/configuration_dynamic.rb

@@ -0,0 +1,67 @@
+require 'yaml'
+require_relative '../vendor/deep_symbolize'
+
+module LoriotRb
+  # we don't want to instantiate this class - it's a singleton,
+  # so just keep it as a self-extended module
+  extend self
+
+  # Appdata provides a basic single-method DSL with .parameter method
+  # being used to define a set of available settings.
+  # This method takes one or more symbols, with each one being
+  # a name of the configuration option.
+  def parameter(*names)
+    names.each do |name|
+      attr_accessor name
+
+      # For each given symbol we generate accessor method that sets option's
+      # value being called with an argument, or returns option's current value
+      # when called without arguments
+      define_method name do |*values|
+        value = values.first
+        value ? self.send("#{name}=", value) : instance_variable_get("@#{name}")
+      end
+    end
+  end
+
+  # And we define a wrapper for the configuration block, that we'll use to set up
+  # our set of options
+  def configure_on_the_fly(&block)
+    instance_eval &block
+  end
+
+  module Settings
+    # again - it's a singleton, thus implemented as a self-extended module
+    extend self
+
+    @_settings = {}
+    attr_reader :_settings
+
+    # This is the main point of entry - we call Settings.load! and provide
+    # a name of the file to read as it's argument. We can also pass in some
+    # options, but at the moment it's being used to allow per-environment
+    # overrides in Rails
+    def load!(filename, options = {})
+      newsets = YAML::load_file(filename)
+      newsets.extend DeepSymbolizable
+      newsets = newsets.deep_symbolize
+      newsets = newsets[options[:env].to_sym] if options[:env] && \
+                                                 newsets[options[:env].to_sym]
+      deep_merge!(@_settings, newsets)
+    end
+
+    # Deep merging of hashes
+    # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+    def deep_merge!(target, data)
+      merger = proc{|key, v1, v2|
+        Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+      target.merge! data, &merger
+    end
+
+    def method_missing(name, *args, &block)
+      @_settings[name.to_sym] ||
+          fail(NoMethodError, "unknown configuration root #{name}", caller)
+    end
+
+  end
+end

data/lib/generators/install_generator.rb

@@ -0,0 +1,33 @@
+require 'rails/generators/base'
+
+module LoriotRb
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc 'Installs LoriotRb configuration files'
+      source_root File.expand_path('../../', __FILE__)
+      # class_option :protocol, :type => :string, :default => 'tls', :desc => "Choose your favorite emulator [tls]"
+
+      def copy_to_local
+        # copy_file '../config/settings.yml', 'config/loriot_rb.yml'
+        copy_file '../config/private_EXAMPLE.yml', 'config/loriot_rb_private.yml'
+        file = 'config/initializers/loriot-rb.rb'
+        copy_file '../config/config.rb', file
+        append_file file do
+          <<-FILE.gsub(/^            /, '')
+            connection_protocol = LoriotRb.configuration.protocol
+            raise 'Define your protocol in the configuration file!' unless connection_protocol
+            raise "Connection protocol #{connection_protocol} not recognized!" unless %w(tls).include?(connection_protocol.to_s)
+            require "loriot-rb/#{connection_protocol}/call"
+            LoriotClient.include LoriotRb::Call
+          
+            %w(loriot_rb_private.yml).each  do |file|
+              filepath = File.join(Rails.root,'config',file)
+              LoriotRb::Settings.load!(filepath,env: LoriotRb.configuration.env) if File.exist? filepath
+            end
+            raise 'Insert your secret data to login on the loriot cloud!' unless LoriotRb::Settings.appid.present? && LoriotRb::Settings.token.present?
+          FILE
+        end
+      end
+    end
+  end
+end

data/lib/loriot-rb.rb

@@ -0,0 +1,47 @@
+# LoriotRb
+# Copyright (C) 2017  Marco Mastrodonato, marco.mastrodonato@fractalgarden.com
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'json'
+require 'socket'
+require 'openssl'
+
+require_relative 'core/configuration'
+require_relative 'core/configuration_dynamic'
+
+module LoriotRb
+  def self.root
+    File.expand_path('../..', __FILE__)
+  end
+end
+
+require_relative 'version'
+require_relative 'loriot-rb/base'
+
+unless defined?(Rails)
+  require_relative 'config/config'
+
+  connection_protocol = LoriotRb.configuration.protocol
+  raise "Define your protocol in the configuration file!" unless connection_protocol
+  raise "Connection protocol #{connection_protocol} not recognized!" unless %w(tls).include?(connection_protocol.to_s)
+  require_relative "loriot-rb/#{connection_protocol}/call"
+  LoriotClient.include LoriotRb::Call
+
+  %w(private.yml).each  do |file|
+    filepath = File.join(LoriotRb.root,'lib','config',file)
+    LoriotRb::Settings.load!(filepath,env: LoriotRb.configuration.env) if File.exist? filepath
+  end
+  raise "Insert your secret data to login on the loriot cloud!" if LoriotRb::Settings.appid.nil? || LoriotRb::Settings.token.nil?
+end
+

data/lib/loriot-rb/base.rb

@@ -0,0 +1,72 @@
+require_relative 'help'
+
+###################################
+# An interface to Loriot Service from Ruby
+###################################
+class LoriotClient
+  include LoriotRb::Base
+
+  # Establish a secure connection to your account on the cloud
+  def initialize(options = {})
+    options = { debug: false,
+                token: LoriotRb::Settings.token,
+                appid: LoriotRb::Settings.appid,
+                host: LoriotRb.configuration.host,
+                port: LoriotRb.configuration.port }.merge(options)
+    @debug = options[:debug]
+    @token = options[:token]
+    @appid = options[:appid]
+    options
+
+    welcome_response = sub_initialize(options)
+
+    raise("Loriot-rb: Cannot connect to host #{options[:host]}:#{options[:port]}") unless welcome_response.index('hello')
+
+  end
+
+  # Send the request to device
+  def send_cmd(options = {})
+    options = { debug: @debug,
+                token: @token,
+                appid: @appid,
+                cmd: "tx",
+                eui: nil,
+                port: 40,
+                confirmed: false,
+                data: "0301"}.merge(options)
+
+    raise("Eui is blank! Should i guess your device?") unless options[:eui]
+    response = sub_send_cmd(options)
+    puts "#{Time.now} Cmd response: #{response}" if options[:debug]
+    response
+  end
+
+  # Receive all data devices from the cloud
+  # Each device sends its data to the cloud
+  def read_data(options = {})
+    options = { debug: @debug }.merge(options)
+    puts "#{Time.now} Waiting for #{@appid} incoming data..." if options[:debug]
+    response = sub_read_data(options)
+    puts "#{Time.now} Received: #{response}" if options[:debug]
+    response
+  end
+
+  # Stay awaiting data from the cloud
+  def listen(options = {}, &block)
+    options = { debug: @debug }.merge(options)
+
+    puts "#{Time.now} Starting Listen #{@appid}" if options[:debug]
+    response = nil
+    begin
+      response = read_data(options)
+      block.call(response) if block
+    end while response && !options[:test]
+    # Return last response
+    response
+  end
+
+  # Close the secure connection with the cloud
+  def quit
+    sub_quit
+  end
+end

data/lib/loriot-rb/help.rb

@@ -0,0 +1,16 @@
+# LoriotRb methods
+module LoriotRb
+  # It contains generic methods
+  module Base
+    private
+
+    # Show tips on usage
+    def loriotrb_help
+      <<-HELP.gsub(/^      /, '')
+      *************************************************************************
+      LoriotRb version #{LoriotRb.version}
+      *************************************************************************
+      HELP
+    end
+  end
+end

data/lib/loriot-rb/tls/call.rb

@@ -0,0 +1,73 @@
+# LoriotRb calling methods
+module LoriotRb
+  # It contains all the methods for selecting the items
+  module Call
+
+    attr_reader :contex, :tcp_socket, :ssl_socket
+
+    private
+
+    def sub_initialize(options={})
+      @context = OpenSSL::SSL::SSLContext.new
+      @tcp_socket = TCPSocket.new(options[:host], options[:port])
+      @ssl_socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, @context)
+      @ssl_socket.sync_close = true
+      @ssl_socket.connect
+      welcome_response = ''
+      @ssl_socket.sysread(512, welcome_response)
+      puts "Welcome response: #{welcome_response}" if options[:debug]
+      welcome_response
+    end
+
+    # Send the request to device
+    def sub_send_cmd(options={})
+      response = ''
+      str_app_token = "{\"appid\":\"#{options[:appid]}\", \"token\":\"#{options[:token]}\"}"
+      puts "#{Time.now} To: #{str_app_token}" if options[:debug]
+      @ssl_socket.puts str_app_token
+      str_request = "{\"cmd\":\"#{options[:cmd]}\",\"EUI\":\"#{options[:eui]}\",\"port\":#{options[:port]},\"confirmed\":#{options[:confirmed]},\"data\":\"#{options[:data]}\"} 	"
+      puts "#{Time.now} Cmq request: #{str_request}" if options[:debug]
+      @ssl_socket.puts(str_request)
+      begin
+        retries ||= 0
+        @ssl_socket.sysread(512, response)
+      rescue EOFError => e
+        if (retries += 1) < 3
+          puts "Attempt ##{retries}..." if options[:debug]
+          sleep 0.5
+          retry
+        else
+          raise e
+        end
+      end
+
+      # Return the json hash from the string
+      JSON.parse(response)
+    end
+
+    # Send the request to device
+    def sub_read_data(options={})
+      response = ''
+      begin
+        retries ||= 0
+        @ssl_socket.sysread(512, response)
+      rescue EOFError => e
+        if (retries += 1) < 3
+          puts "Attempt ##{retries}..." if options[:debug]
+          sleep 0.5
+          retry
+        else
+          raise e
+        end
+      end
+
+      # Return the json hash from the string
+      JSON.parse(response)
+    end
+
+    def sub_quit
+      @ssl_socket.close
+    end
+
+  end
+end

data/lib/vendor/deep_symbolize.rb

@@ -0,0 +1,60 @@
+# Symbolizes all of hash's keys and subkeys.
+# Also allows for custom pre-processing of keys (e.g. downcasing, etc)
+# if the block is given:
+#
+# somehash.deep_symbolize { |key| key.downcase }
+#
+# Usage: either include it into global Hash class to make it available to
+#        to all hashes, or extend only your own hash objects with this
+#        module.
+#        E.g.:
+#        1) class Hash; include DeepSymbolizable; end
+#        2) myhash.extend DeepSymbolizable
+
+module DeepSymbolizable
+  def deep_symbolize(&block)
+    method = self.class.to_s.downcase.to_sym
+    syms = DeepSymbolizable::Symbolizers
+    syms.respond_to?(method) ? syms.send(method, self, &block) : self
+  end
+
+  module Symbolizers
+    extend self
+
+    # the primary method - symbolizes keys of the given hash,
+    # preprocessing them with a block if one was given, and recursively
+    # going into all nested enumerables
+    def hash(hash, &block)
+      hash.inject({}) do |result, (key, value)|
+        # Recursively deep-symbolize subhashes
+        value = _recurse_(value, &block)
+
+        # Pre-process the key with a block if it was given
+        key = yield key if block_given?
+        # Symbolize the key string if it responds to to_sym
+        sym_key = key.to_sym rescue key
+
+        # write it back into the result and return the updated hash
+        result[sym_key] = value
+        result
+      end
+    end
+
+    # walking over arrays and symbolizing all nested elements
+    def array(ary, &block)
+      ary.map { |v| _recurse_(v, &block) }
+    end
+
+    # handling recursion - any Enumerable elements (except String)
+    # is being extended with the module, and then symbolized
+    def _recurse_(value, &block)
+      if value.is_a?(Enumerable) && !value.is_a?(String)
+        # support for a use case without extended core Hash
+        value.extend DeepSymbolizable unless value.class.include?(DeepSymbolizable)
+        value = value.deep_symbolize(&block)
+      end
+      value
+    end
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+module LoriotRb
+  def self.version
+    "0.4.0"
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: loriot-rb
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Marco Mastrodonato
+- Rudi Petazzi
+- Stefano Piras
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: This gem let you to connect to Loriot cloud system and manage your registered
+  devices.
+email:
+- marco.mastrodonato@fractalgarden.com
+- rudi.petazzi@fractalgarden.com
+- stefano.piras@fractalgarden.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/config/config.rb
+- lib/config/private.yml
+- lib/config/private_EXAMPLE.yml
+- lib/core/configuration.rb
+- lib/core/configuration_dynamic.rb
+- lib/generators/install_generator.rb
+- lib/loriot-rb.rb
+- lib/loriot-rb/base.rb
+- lib/loriot-rb/help.rb
+- lib/loriot-rb/tls/call.rb
+- lib/vendor/deep_symbolize.rb
+- lib/version.rb
+homepage: 
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- The brave to dare
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Manage your devices with Loriot cloud system
+test_files: []