losant_mqtt 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 075c878237e2446169818a1add9b9b7497880e61
+  data.tar.gz: 69a11a70d3a5fa625027cbee1ca02ebe62295d25
+SHA512:
+  metadata.gz: a04c6e4628b47c1b5c790514cb57b810696f3757586114a014f4fee5e2f7137716e7f4e93b3d19aa4dda91d158d18bfc8a32822aa2ce048f2d452fcc790194c4
+  data.tar.gz: 9202ed8fb8a0e83ca247059aec4c00f2dddfeab2def0c6d6d85df46da3afd1ca45dedf5e158c2b76eb61f218762f1819e7b91f73bd374469955068373d039b3d

data/.gitignore

@@ -0,0 +1,23 @@
+*~
+\#*
+.\#*
+.DS_Store
+*_flymake.*
+*.LCK
+.bundle
+vendor/bundle
+bin
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+_yardoc
+coverage
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Gemfile.lock

data/.rbenv-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+ - 2.3.1
+ - 2.2.5
+ - 2.1.10

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Losant IoT, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,248 @@
+# Losant Ruby MQTT Client
+
+[![Build Status](https://travis-ci.org/Losant/losant-mqtt-ruby.svg?branch=master)](https://travis-ci.org/Losant/losant-mqtt-ruby)
+
+The [Losant](https://www.losant.com) MQTT client provides a simple way for
+custom things to communicate with the Losant platform over MQTT.  You can
+authenticate as a device, publish device state, and listen for device commands.
+
+This client works with Ruby 2.1 and higher, and it depends on [Event Machine](https://github.com/eventmachine/eventmachine) to provide
+event-driven I/O.
+
+<br/>
+
+## Installation
+
+The latest stable version is available in RubyGems and can be installed using
+
+```bash
+gem install losant_mqtt
+```
+
+<br/>
+
+## Example
+
+Below is a high-level example of using the Losant Ruby MQTT client to send
+the value of a temperature sensor to the Losant platform.
+
+```ruby
+require "losant_mqtt"
+
+EventMachine.run do
+
+  # Construct device
+  device = LosantMqtt::Device.new(
+    device_id: "my-device-id",
+    key: "my-app-access-key",
+    secret: "my-app-access-secret")
+
+  # Send temperature once every ten seconds.
+  EventMachine::PeriodicTimer.new(10.0) do
+    temp = call_out_to_your_sensor_here()
+    device.send_state({ temperature: temp })
+    puts "#{device.device_id}: Sent state"
+  end
+
+  # Listen for commands.
+  device.on(:command) do |d, command|
+    puts "#{d.device_id}: Command received."
+    puts command["name"]
+    puts command["payload"]
+  end
+
+  # Listen for connection event
+  device.on(:connect) do |d|
+    puts "#{d.device_id}: Connected"
+  end
+
+  # Listen for reconnection event
+  device.on(:reconnect) do |d|
+    puts "#{d.device_id}: Reconnected"
+  end
+
+  # Listen for disconnection event
+  device.on(:close) do |d, reason|
+    puts "#{d.device_id}: Lost connection (#{reason})"
+  end
+
+  # Connect to Losant.
+  device.connect
+end
+```
+
+<br/>
+
+## API Documentation
+
+*   [Device](#device)
+    *   [initializer](#initializer)
+    *   [connect](#connect)
+    *   [connected?](#connected)
+    *   [close](#close)
+    *   [send_state](#send_state)
+    *   [on](#on)
+    *   [add_listener](#add_listener)
+    *   [remove_listener](#remove_listener)
+
+### Device
+
+A device represents a single thing or widget that you'd like to connect to
+the Losant platform. A single device can contain many different sensors or
+other attached peripherals. Devices can either report state or
+respond to commands.
+
+A device's state represents a snapshot of the device at some point in time.
+If the device has a temperature sensor, it might report state every few seconds
+with the temperature. If a device has a button, it might only report state when
+the button is pressed. Devices can report state as often as needed by your
+specific application.
+
+Commands instruct a device to take a specific action. Commands are defined as a
+name and an optional payload. For example, if the device is a scrolling marquee,
+the command might be "update text" and the payload would include the text
+to update.
+
+#### initializer
+
+```ruby
+LosantMqtt::Device.new(device_id:, key:, secret:, secure: true, retry_lost_connection: true)
+```
+
+The ``Client()`` initializer takes the following arguments:
+
+*   device_id  
+The device's ID. Obtained by first registering a device using
+the Losant platform.
+
+*   key  
+The Losant access key.
+
+*   secret  
+The Losant access secret.
+
+*   secure  
+If the client should connect to Losant over SSL - default is true.
+
+*   retry_lost_connection  
+If the client should retry lost connections - default is true.  Errors on
+initial connect will still be raised, but if a good connection is
+subsequently lost and this flag is true, the client will try to automatically
+reconnect and will not raise errors (except in the case of authentication
+errors, which will still be raised). When this flag is true, disconnection
+and reconnection can be monitored using the `:close` and `:reconnect` events.
+
+###### Example
+
+```ruby
+device = LosantMqtt::Device.new(device_id: "my-device-id",
+  key: "my-app-access-key", secret: "my-app-access-secret")
+```
+
+#### connect
+
+```ruby
+connect()
+```
+
+Connects the device to the Losant platform. Hook the `:connect` event to know when
+a connection has been successfully established.  Returns the device instance
+to allow chaining.
+
+#### connected?
+
+```ruby
+connected?()
+```
+
+Returns a boolean indicating whether or not the device is currently connected
+to the Losant platform.
+
+#### close
+
+```ruby
+close()
+```
+
+Closes the device's connection to the Losant platform.
+
+#### send_state
+
+```ruby
+send_state(state, time = nil)
+```
+
+Sends a device state to the Losant platform. In many scenarios, device
+states will change rapidly. For example a GPS device will report GPS
+coordinates once a second or more. Because of this, sendState is typically
+the most invoked function. Any state data sent to Losant is stored and made
+available in data visualization tools and workflow triggers.
+
+*   state  
+The state to send as a hash.
+
+*   time  
+When the state occured - if nil or not set, will default to now.
+
+###### Example
+
+```ruby
+device.send_state({ voltage: read_analog_in() })
+```
+
+#### on
+
+```ruby
+on(event, proc=nil, &block)
+```
+
+Adds an observer to listen for an event on this device.
+
+*   event  
+The event name to listen for.  Possible events are: `:connect` (the device
+has connected), `:reconnect` (the device lost its connection and reconnected),
+`:close` (the device's connection was closed), and
+`:command` (the device has received a command from Losant).
+
+*   proc / &block  
+The proc or block to call with the given event fires.  The first
+argument for all callbacks will be the device instance.  For `:close` callbacks,
+there can be a second argument which is the reason for the closing of the
+connection, and for `:command` callbacks the second argument is the command
+received.
+
+###### Example
+
+```ruby
+device.on(:command) do |device, command|
+  puts "Command received."
+  puts command["name"]
+  puts command["payload"]
+end
+```
+
+#### add_listener
+
+An alias to [on](#on).
+
+#### remove_listener
+
+```ruby
+remove_listener(event, proc)
+```
+
+Removes an observer from listening for an event on this device.
+
+*   event  
+The event name to stop listening for.  Same events as [on](#on).
+
+*   proc  
+The proc that should be removed.
+
+<br/>
+
+*****
+
+Copyright (c) 2016 Losant IoT, Inc
+
+<https://www.losant.com>

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => :spec

data/lib/losant_mqtt.rb

@@ -0,0 +1,26 @@
+require "openssl"
+require "date"
+require "json"
+
+require "mqtt"
+require "eventmachine"
+require "events"
+
+require_relative "losant_mqtt/version"
+require_relative "losant_mqtt/utils"
+require_relative "losant_mqtt/device_connection"
+require_relative "losant_mqtt/device"
+
+module LosantMqtt
+  COMMAND_TOPIC    = "losant/%{device_id}/command"
+  STATE_TOPIC      = "losant/%{device_id}/state"
+  DEFAULT_ENDPOINT = "broker.losant.com"
+
+  def self.endpoint
+    @endpoint || DEFAULT_ENDPOINT
+  end
+
+  def self.endpoint=(domain)
+    @endpoint = domain
+  end
+end

data/lib/losant_mqtt/RootCA.crt

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
+ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
+MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
+LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
+RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
+PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
+xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
+Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
+hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
+EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
+FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
+nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
+eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
+hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
+Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
++OkuE6N36B9K
+-----END CERTIFICATE-----

data/lib/losant_mqtt/device.rb

@@ -0,0 +1,135 @@
+module LosantMqtt
+  class Device
+    include Events::Emitter
+
+    attr_reader :device_id, :key, :secret, :secure, :should_retry
+
+    def initialize(options = {})
+      @was_connected = false
+
+      @device_id     = options[:device_id].to_s
+      @key           = options[:key].to_s
+      @secret        = options[:secret].to_s
+      @secure        = options.has_key?(:secure) ? !!options[:secure] : true
+      @should_retry  = options.has_key?(:retry_lost_connection) ?
+        !!options[:retry_lost_connection] : true
+
+      raise ArgumentError.new("Invalid Device Id") if @device_id == ""
+      raise ArgumentError.new("Invalid Key") if @key == ""
+      raise ArgumentError.new("Invalid Secret") if @secret == ""
+    end
+
+    def connected?
+      !!(@connection && @connection.connected?)
+    end
+
+    def connect
+      return self if @retry_timer || @connection
+
+      begin
+        @connection = DeviceConnection.connect(
+          host:      LosantMqtt.endpoint,
+          port:      @secure ? 8883 : 1883,
+          secure:    @secure,
+          username:  @key,
+          password:  @secret,
+          client_id: @device_id)
+      rescue Exception => ex
+        if @was_connected && @should_retry
+          @connection = nil
+          emit(:close, self, ex)
+          retry_lost_connection
+          return self
+        else
+          raise ex
+        end
+      end
+
+      @connection.on(:disconnected) do |reason|
+        @connection = nil
+        emit(:close, self, reason)
+
+        if reason
+          if @was_connected && @should_retry && !(reason.message =~ /Authentication Error/)
+            # if it was not an authentication error
+            # and we ave successfully connected before
+            # attempt to reconnect in a few seconds
+            retry_lost_connection
+          else
+            raise reason
+          end
+        end
+      end
+
+      @connection.on(:connected) do
+        if(@state_backlog)
+          @connection.publish(state_topic, @state_backlog.to_json)
+          @state_backlog = nil
+        end
+
+        if @was_connected
+          emit(:reconnect, self)
+        else
+          @was_connected = true
+          emit(:connect, self)
+        end
+
+        @connection.subscribe(command_topic) do |msg|
+          begin
+            msg = Utils.convert_ext_json(JSON.parse(msg))
+          rescue JSON::ParserError
+            msg = nil
+          end
+          emit(:command, self, msg) if msg
+        end
+      end
+
+      self
+    end
+
+    def close
+      @connection.disconnect if @connection
+      if @retry_timer
+        @retry_timer.cancel
+        @retry_timer = nil
+      end
+      true
+    end
+
+    def send_state(state, time = nil)
+      connect unless @connection
+
+      time ||= Time.now
+      time = time.to_time if time.respond_to?(:to_time)
+      time = time.to_f
+      time = time * 1000 if time < 1000000000000 # convert to ms since epoch
+      time = time.round
+
+      payload = { time: time, data: state }
+
+      if connected?
+        @connection.publish(state_topic, payload.to_json)
+      else
+        (@state_backlog ||= []).push(payload)
+      end
+
+      true
+    end
+
+    def retry_lost_connection(wait=5)
+      return false if @connection
+      @retry_timer ||= EventMachine::Timer.new(wait) do
+        @retry_timer = nil
+        connect
+      end
+    end
+
+    def state_topic
+      @state_topic ||= LosantMqtt::STATE_TOPIC % { device_id: @device_id }
+    end
+
+    def command_topic
+      @command_topic ||= LosantMqtt::COMMAND_TOPIC % { device_id: @device_id }
+    end
+  end
+end

data/lib/losant_mqtt/device_connection.rb

@@ -0,0 +1,208 @@
+module LosantMqtt
+  CA_FILE_PATH = File.expand_path(File.join(File.dirname(__FILE__), "RootCA.crt"))
+
+  class DeviceConnection < EventMachine::Connection
+    include Events::Emitter
+
+    attr_reader :state
+
+    def self.connect(options = {})
+      options = { host: "localhost", port: MQTT::DEFAULT_PORT }.merge(options)
+      EventMachine.connect(options[:host], options[:port], self, options)
+    end
+
+    def initialize(options = {})
+      @options = {
+        client_id:     MQTT::Client.generate_client_id,
+        keep_alive:    15,
+        clean_session: true,
+        username:      nil,
+        password:      nil,
+        version:       "3.1.1"
+      }.merge(options)
+      @subscriptions = {}
+    end
+
+    def connected?
+      state == :connected
+    end
+
+    def publish(topic, payload)
+      send_packet(MQTT::Packet::Publish.new(
+        id:      next_packet_id,
+        qos:     0,
+        retain:  false,
+        topic:   topic,
+        payload: payload))
+    end
+
+    def subscribe(topic, &block)
+      @subscriptions[topic] = block
+      send_packet(MQTT::Packet::Subscribe.new(id: next_packet_id, topics: [topic]))
+    end
+
+    def unsubscribe(topic)
+      @subscriptions.delete(topic)
+      send_packet(MQTT::Packet::Unsubscribe.new(id: next_packet_id, topics: [topic]))
+    end
+
+    def disconnect(send_msg: true)
+      return if @state == :disconnecting || @state == :disconnected
+      packet = connected? && send_msg && MQTT::Packet::Disconnect.new
+      @state = :disconnecting
+      emit(@state)
+      packet ? send_packet(packet) : close_connection
+    end
+
+    def send_connect_packet
+      packet = MQTT::Packet::Connect.new(
+        client_id:     @options[:client_id],
+        clean_session: @options[:clean_session],
+        keep_alive:    @options[:keep_alive],
+        username:      @options[:username],
+        password:      @options[:password],
+        version:       @options[:version])
+      send_packet(packet)
+      @state = :connect_sent
+      emit(@state)
+    end
+
+    def process_packet(packet)
+      @last_received = Time.now.to_i
+      if state == :connect_sent && packet.class == MQTT::Packet::Connack
+        connect_ack(packet)
+      elsif state == :connected && packet.class == MQTT::Packet::Pingresp
+        # Pong!
+      elsif state == :connected && packet.class == MQTT::Packet::Publish
+        @subscriptions[packet.topic].call(packet.payload) if @subscriptions[packet.topic]
+      elsif state == :connected && packet.class == MQTT::Packet::Puback
+        # publish acked
+      elsif state == :connected && packet.class == MQTT::Packet::Suback
+        # Subscribed!
+      elsif state == :connected && packet.class == MQTT::Packet::Unsuback
+        # Unsubscribed!
+      else
+        # CONNECT only sent by client
+        # SUBSCRIBE only sent by client
+        # PINGREQ only sent by client
+        # UNSUBSCRIBE only sent by client
+        # DISCONNECT only sent by client
+        # PUBREC/PUBREL/PUBCOMP for QOS2 - do not support
+        @ex = MQTT::ProtocolException.new("Wasn't expecting packet of type #{packet.class} when in state #{state}")
+        close_connection
+      end
+    end
+
+    def connect_ack(packet)
+      if packet.return_code != 0x00
+        @ex = MQTT::ProtocolException.new("Authentication Error - " + packet.return_msg)
+        return close_connection
+      end
+
+      @state = :connected
+
+      if @options[:keep_alive] > 0
+        @timer = EventMachine::PeriodicTimer.new(@options[:keep_alive]) do
+          if(Time.now.to_i - @last_received > @options[:keep_alive])
+            @ex = MQTT::NotConnectedException.new("Keep alive failure, disconnecting")
+            close_connection
+          else
+            send_packet(MQTT::Packet::Pingreq.new)
+          end
+        end
+      end
+
+      emit(@state)
+    end
+
+    def next_packet_id
+      @packet_id += 1
+    end
+
+    def send_packet(packet)
+      send_data(packet.to_s)
+    end
+
+    def unbind(msg)
+      if @timer
+        @timer.cancel
+        @timer = nil
+      end
+
+      unless @state == :disconnecting
+        @ex ||= $! || MQTT::NotConnectedException.new("Connection to server lost")
+      end
+
+      @state = :disconnected
+      emit(@state, @ex)
+      @ex = nil
+    end
+
+    def receive_data(data)
+      @data << data
+
+      # Are we at the start of a new packet?
+      if !@packet && @data.length >= 2
+        @packet = MQTT::Packet.parse_header(@data)
+      end
+
+      # Do we have the the full packet body now?
+      if @packet && @data.length >= @packet.body_length
+        @packet.parse_body(@data.slice!(0...@packet.body_length))
+        process_packet(@packet)
+        @packet = nil
+        receive_data("")
+      end
+    end
+
+    def post_init
+      @state         = :connecting
+      @last_received = 0
+      @packet_id     = 0
+      @packet        = nil
+      @data          = ""
+      @ex            = nil
+      emit(@state)
+    end
+
+    def connection_completed
+      if @options[:secure]
+        @last_seen_cert    = nil
+        @certificate_store = OpenSSL::X509::Store.new
+        @certificate_store.add_file(CA_FILE_PATH)
+        start_tls(:verify_peer => true)
+      else
+        send_connect_packet
+      end
+    end
+
+    def ssl_verify_peer(cert_string)
+      @last_seen_cert = OpenSSL::X509::Certificate.new(cert_string)
+      unless @certificate_store.verify(@last_seen_cert)
+        @ex = OpenSSL::OpenSSLError.new("Unable to verify the certificate for #{@options[:host]}")
+        return false
+      end
+
+      begin
+        @certificate_store.add_cert(@last_seen_cert)
+      rescue OpenSSL::X509::StoreError => e
+        unless e.message == "cert already in hash table"
+          @ex = e
+          return false
+        end
+      end
+
+      true
+    end
+
+    def ssl_handshake_completed
+      unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, @options[:host])
+        @ex = OpenSSL::OpenSSLError.new("The hostname #{@options[:host]} does not match the server certificate")
+        return close_connection
+      end
+
+      send_connect_packet
+    end
+
+  end
+end

data/lib/losant_mqtt/utils.rb

@@ -0,0 +1,26 @@
+module LosantMqtt
+  module Utils
+
+    def self.convert_ext_json(value)
+      if value.respond_to?(:to_ary)
+        value = value.to_ary.map{ |v| convert_ext_json(v) }
+      end
+
+      if value.respond_to?(:to_hash)
+        value = value.to_hash
+        if value.length == 1 && value.has_key?("$date")
+          value = ::DateTime.parse(value["$date"])
+        elsif value.length == 1 && value.has_key?("$undefined")
+          value = nil
+        else
+          value.each do |k, v|
+            value[k] = convert_ext_json(v)
+          end
+        end
+      end
+
+      value
+    end
+
+  end
+end

data/lib/losant_mqtt/version.rb

@@ -0,0 +1,3 @@
+module LosantMqtt
+  VERSION = "1.0.0"
+end

data/losant_mqtt.gemspec

@@ -0,0 +1,24 @@
+$LOAD_PATH.push(File.expand_path("../lib", __FILE__))
+require "losant_mqtt/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "losant_mqtt"
+  gem.authors       = ["Michael Kuehl"]
+  gem.email         = ["hello@losant.com"]
+  gem.summary       = %q{An MQTT client for the Losant MQTT Broker}
+  gem.description   = %q{Easily use the Losant IoT Platform through its MQTT Broker with Ruby}
+  gem.homepage      = "https://www.losant.com"
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.version       = LosantMqtt::VERSION
+  gem.licenses      = ["MIT"]
+
+  gem.add_runtime_dependency "eventmachine", "~> 1.2.0"
+  gem.add_runtime_dependency "mqtt", "~> 0.3.0"
+  gem.add_runtime_dependency "events", "~> 0.9.0"
+
+  gem.add_development_dependency "rspec", "~> 3.0"
+  gem.add_development_dependency "rake", "~> 11"
+end

data/spec/device_spec.rb

@@ -0,0 +1,197 @@
+require "losant_mqtt"
+
+describe LosantMqtt::Device do
+
+  it "raises error on missing required initializer args" do
+    expect do
+      LosantMqtt::Device.new(key: "key", secret: "secret")
+    end.to raise_error(ArgumentError)
+
+    expect do
+      LosantMqtt::Device.new(device_id: "device_id", secret: "secret")
+    end.to raise_error(ArgumentError)
+
+    expect do
+      LosantMqtt::Device.new(device_id: "device_id", key: "key")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should correctly connect, send state, and receive a command" do
+    EventMachine.run do
+      EventMachine.add_timer(5) { raise RuntimeError.new("Test Timed Out") }
+
+      # associated with app id 57615eebc035bd0100cb964a
+      # workflow that takes state reported and sends a command back
+      device = LosantMqtt::Device.new(
+        device_id: ENV["DEVICE_ID"] || "57615f0ac035bd0100cb964b",
+        key: ENV["LOSANT_KEY"] || "0bbdc673-77ea-423f-9241-976db4776f8b",
+        secret: ENV["LOSANT_SECRET"])
+      expect(device.connected?).to eq(false)
+
+      callbacks_called = []
+
+      device.on(:command) do |d, cmd|
+        expect(d.connected?).to eq(true)
+        callbacks_called.push(:command)
+        expect(cmd["name"]).to eq("triggeredCommand")
+        expect(cmd["payload"]).to eq({ "result" => "one-1-false" })
+        d.close
+      end
+
+      device.on(:connect) do |d|
+        expect(d.connected?).to eq(true)
+        callbacks_called.push(:connect)
+      end
+
+      device.on(:reconnect) do
+        callbacks_called.push(:reconnect)
+      end
+
+      device.on(:close) do |d, reason|
+        expect(d.connected?).to eq(false)
+        expect(reason).to eq(nil)
+        expect(callbacks_called).to eq([:connect, :command])
+        EventMachine.stop_event_loop
+      end
+
+      device.send_state({ str_attr: "one", num_attr: 1, bool_attr: false })
+    end
+  end
+
+  it "should reconnect when connection is abnormally lost and flag is true" do
+    EventMachine.run do
+      EventMachine.add_timer(10) { raise RuntimeError.new("Test Timed Out") }
+
+      # associated with app id 57615eebc035bd0100cb964a
+      # workflow that takes state reported and sends a command back
+      device = LosantMqtt::Device.new(
+        device_id: ENV["DEVICE_ID"] || "57615f0ac035bd0100cb964b",
+        key: ENV["LOSANT_KEY"] || "0bbdc673-77ea-423f-9241-976db4776f8b",
+        secret: ENV["LOSANT_SECRET"])
+      expect(device.connected?).to eq(false)
+
+      callbacks_called = []
+
+      device.on(:command) do |d, cmd|
+        expect(d.connected?).to eq(true)
+        callbacks_called.push(:command)
+        expect(cmd["name"]).to eq("triggeredCommand")
+        expect(cmd["payload"]).to eq({ "result" => "two-2-true" })
+        d.close
+      end
+
+      device.on(:connect) do |d|
+        expect(d.connected?).to eq(true)
+        callbacks_called.push(:connect)
+        EventMachine.add_timer(0.1) do
+          # abnormally force close underlying socket
+          d.instance_variable_get("@connection").close_connection
+        end
+      end
+
+      device.on(:reconnect) do |d|
+        expect(d.connected?).to eq(true)
+        callbacks_called.push(:reconnect)
+        d.send_state({ str_attr: "two", num_attr: 2, bool_attr: true })
+      end
+
+      close_count = 0
+      device.on(:close) do |d, reason|
+        expect(d.connected?).to eq(false)
+        callbacks_called.push(:close)
+        close_count += 1
+        if close_count == 1
+          expect(callbacks_called).to eq([:connect, :close])
+          expect(reason.message).to eq("Connection to server lost")
+        else
+          expect(reason).to eq(nil)
+          expect(callbacks_called).to eq([:connect, :close, :reconnect, :command, :close])
+          EventMachine.stop_event_loop
+        end
+      end
+
+      device.connect
+    end
+  end
+
+  it "should not reconnect when connection is abnormally lost and flag is false" do
+    expect do
+      EventMachine.run do
+        EventMachine.add_timer(10) { raise RuntimeError.new("Test Timed Out") }
+
+        # associated with app id 57615eebc035bd0100cb964a
+        # workflow that takes state reported and sends a command back
+        device = LosantMqtt::Device.new(
+          device_id: ENV["DEVICE_ID"] || "57615f0ac035bd0100cb964b",
+          key: ENV["LOSANT_KEY"] || "0bbdc673-77ea-423f-9241-976db4776f8b",
+          secret: ENV["LOSANT_SECRET"],
+          retry_lost_connection: false)
+        expect(device.connected?).to eq(false)
+
+        callbacks_called = []
+
+        device.on(:reconnect) do
+          callbacks_called.push(:reconnect)
+        end
+
+        device.on(:command) do
+          callbacks_called.push(:command)
+        end
+
+        device.on(:connect) do |d|
+          expect(d.connected?).to eq(true)
+          callbacks_called.push(:connect)
+          EventMachine.add_timer(0.1) do
+            # abnormally force close underlying socket
+            d.instance_variable_get("@connection").close_connection
+          end
+        end
+
+        device.on(:close) do |d, reason|
+          expect(d.connected?).to eq(false)
+          callbacks_called.push(:close)
+          expect(callbacks_called).to eq([:connect, :close])
+          expect(reason.message).to eq("Connection to server lost")
+        end
+
+        device.connect
+      end
+    end.to raise_error(MQTT::NotConnectedException)
+  end
+
+  it "should raise errors on initial bad connect" do
+    expect do
+      EventMachine.run do
+        EventMachine.add_timer(10) { raise RuntimeError.new("Test Timed Out") }
+        device = LosantMqtt::Device.new(
+          device_id: "not a device id",
+          key: "not a key",
+          secret: "not a secret")
+
+        callbacks_called = []
+
+        device.on(:reconnect) do
+          callbacks_called.push(:reconnect)
+        end
+
+        device.on(:command) do
+          callbacks_called.push(:command)
+        end
+
+        device.on(:connect) do
+          callbacks_called.push(:connect)
+        end
+
+        device.on(:close) do |d, reason|
+          expect(d.connected?).to eq(false)
+          callbacks_called.push(:close)
+          expect(callbacks_called).to eq([:close])
+          expect(reason.message).to eq("Authentication Error - Connection refused: not authorised")
+        end
+
+        device.connect
+      end
+    end.to raise_error(MQTT::ProtocolException)
+  end
+
+end

data/testing.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.push(File.expand_path("../lib", __FILE__));
+require "losant_mqtt"
+
+EventMachine.run do
+  device = LosantMqtt::Device.new(
+    key: "0bbdc673-77ea-423f-9241-976db4776f8b",
+    secret: "191bcd2c2512a770a880460f04f46ccf295c414a44b41742c9f3fe0746245fa8",
+    device_id: "57615f0ac035bd0100cb964b")
+
+  EventMachine::PeriodicTimer.new(10.0) do
+    temp = 10
+    device.send_state({ temperature: temp })
+    puts "#{device.device_id}: Sent state"
+  end
+
+  device.on(:command) do |d, command|
+    puts "#{d.device_id}: Command received."
+    puts command["name"]
+    puts command["payload"]
+  end
+
+  device.on(:connect) do |d|
+    puts "#{d.device_id}: Connected"
+  end
+
+  device.on(:reconnect) do |d|
+    puts "#{d.device_id}: Reconnected"
+  end
+
+  device.on(:close) do |d, reason|
+    puts "#{d.device_id}: Lost connection (#{reason})"
+  end
+
+  device.connect
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: losant_mqtt
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Kuehl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: mqtt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: events
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+description: Easily use the Losant IoT Platform through its MQTT Broker with Ruby
+email:
+- hello@losant.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rbenv-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/losant_mqtt.rb
+- lib/losant_mqtt/RootCA.crt
+- lib/losant_mqtt/device.rb
+- lib/losant_mqtt/device_connection.rb
+- lib/losant_mqtt/utils.rb
+- lib/losant_mqtt/version.rb
+- losant_mqtt.gemspec
+- spec/device_spec.rb
+- testing.rb
+homepage: https://www.losant.com
+licenses:
+- MIT
+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.6.4
+signing_key: 
+specification_version: 4
+summary: An MQTT client for the Losant MQTT Broker
+test_files:
+- spec/device_spec.rb