apiotics-test 0.1.49

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74dc3049ede534877349365340d48559dbbb4b41
+  data.tar.gz: 392128d01db6b10264cb4aa36391542cbfc93d67
+SHA512:
+  metadata.gz: df3572837f9b03a4078bcf8b0fd76dbe8ab582645ae2c80b0d5bab8e3f8e821016a4792ab8337e0401633da5d4282bc6618fb8a29ae149df033b095ff7ba947a
+  data.tar.gz: ed4ac85ae1fa4a741467bb7e61da422552a422fd33fd84b9da4bb3ed438af52b50da207448960f244be994562a84a312e7d56a9bc0921ce5f6cdd7b5792a080b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 MicroArx Corporation
+
+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,260 @@
+# Apiotics
+The easy way to make your Rails application interact with IoT devices.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "apiotics"
+```
+
+Or install it yourself as:
+```bash
+$ gem install apiotics
+```
+
+And then execute:
+```bash
+$ bundle
+$ rails generate apiotics:install
+```
+On the Apiotics portal located at www.apiotics.com, you can create a Hive for your project. Hives have Workers (each type of IoT device in your project will have a corresponding worker in the Hive).  Workers have Drivers and, optionally, Scripts.  Drivers and Scripts have interfaces.  An example worker might be a Thermostat.  The Thermostat has a Control Script with two interfaces: temperature and target temperature.  If you set the target temperature to 72 and the temperature is 65, the Thermostat will turn the heat on.  We'll use this example again and flesh it out below.
+
+Once you have created a Hive, it will give you a public and a private API key.  Best practice is to set environment variables in your development, test and production environments to equal these API keys.  Then, set config.public_key and config.private_key in config/initializers/apiotics.rb to those environment variables.  You can enter the API keys directly into the configuration file, but you should only do this if you never plan to put your Rails application and Hive into production, as it is a significant security risk.
+
+
+```ruby
+Apiotics.configure do |config|
+	config.public_key = ENV['SIMBIOTES_PUBLIC_API_KEY']
+	config.private_key = ENV['SIMBIOTES_PRIVATE_API_KEY']
+	config.local_port = 8001
+	config.server_port = 8000
+	config.local_logging = true
+end
+```
+
+## Usage
+After you have installed the API keys, log in to the Apiotics portal (www.apiotics.com) to see that your Hive has Workers and that those Workers have Drivers and, if applicable, Scripts defined.  Each Worker, Driver or Script will have one or more Interfaces.  For example, if you are making a connected Thermostat, your Hive might have a Worker named 'Thermostat' and it might have the following Drivers/Scripts: Thermometer, Furnace and Control.
+
+Each of the Drivers/Scripts has Interfaces (all of this would be viewable on the www.apiotics.com portal).  The Control script might have two interfaces: Temperature and Target Temperature.
+
+We want to be able to interact with these interfaces easily through our Rails application for all of the Thermostats that we have out there in the field.
+
+### Models and Tables
+
+To do this, we will create a model in our Rails application with attributes that correspond to the interfaces we want to interact with.  We will then create records in our Rails database that correspond to our devices.  Once we've done that, we can interact with a database record using ActiveRecord as usual, but the attribute values from our database records will be automatically synced to the corresponding device.
+
+Because our model is going to sync with our IoT devices, we need to use the Apiotics model generator that comes with the gem to create the model rather than the model generator that comes by default with Rails.  To use it, we pass two arguments, the name of the Worker and the name of the Driver or Script that we want to interact with.  In this case, our worker is Thermostat and we want to interact with Control, so we create the model as follows:
+
+```bash
+$ rails generate apiotics:model Thermostat Control
+```
+
+This generator actually creates a model and a module.  The module is in app/models/thermostat.rb and the model in app/models/thermostat/control.rb.  If you create models that correspond to one or more of your Thermostat's other Drivers/Scripts, they will be placed in the app/models/thermostat directory as well.
+
+Now you should migrate your database in order to create the database tables that correspond to your model.
+
+```bash
+$ rake db:migrate
+```
+
+The migration creates three tables: thermostat_controls, thermostat_control_temperature_logs and thermostat_control_target_temperature_logs.  The thermostat_controls table holds the data for temperature and target temperature for all of the devices within your Hive.  
+
+### Instances and Devices
+
+Now that you have your models and database tables created, you can use them to communicate with the devices that are out in the field.
+
+The first thing to do is to create database records that correspond to actual devices.  On the Apiotics Portal (www.apiotics.com) you will see a list of Worker Instances (each Instance represents an individual device of that particular Worker type) on each Worker page.  Each Worker Instance has an id, you'll see them as a long string of characters on the page, one for each Worker Instance.
+
+Now, run:
+
+```bash
+$ rails console
+```
+
+This will open up an irb console with your Rails environment (including the Apiotics gem) loaded.
+
+In your console run:
+
+```irb
+> Thermostat.sync_device_instances
+```
+
+That will create a database record for each device instance you currently have defined in for your Thermostat worker.  If you have no instances defined, create one on the Thermostat worker page in the apiotics.com portal.
+
+Next, exit your rails console by typing:
+
+```irb
+> exit
+```
+
+The next thing we need to do is establish a communications channel we can use to communicate between our Rails application and the devices in the field.  To do this, we use a local server that handles sending communications to the remote devices and handles communications that we will receive from them.
+
+To start it up in production:
+
+```bash
+$ rake comms:start
+```
+
+In development:
+
+```bash
+$ rake dev_comms:start
+```
+
+In test:
+
+```bash
+$ rake test_comms:start
+```
+
+This starts our communications server.  If you want to stop the communications server for any reason simply:
+
+In production:
+
+```bash
+$ rake comms:stop
+```
+
+In development:
+
+```bash
+$ rake dev_comms:stop
+```
+
+In test:
+
+```bash
+$ rake test_comms:stop
+```
+
+Note that you can only communicate with devices if the local communications server is running.
+
+### Communicating with Devices
+
+Now that the preliminaries are out of the way, let's communicate with devices.
+
+Open up your rails console again by typing:
+
+```bash
+$ rails c
+```
+
+In your console, type the following to get a device instance and assign it to the variable d:
+
+```irb
+> d = Thermostat::Control.first
+```
+
+The first thing to do is to synchronize the database's data with the data from the device. (This sends a get request for each Interface in the current Driver/Script)  To do this type in your console:
+
+```irb
+> d.sync
+```
+
+Now that you are synced with the device, you can set the device's Interfaces easily right from Rails.  Let's say you want to set the temperature of your thermostat to 68 degrees.  Here's how you do it:
+
+```irb
+> d.target_temperature = 68
+> d.save
+```
+
+All of the communications to the device are taken care of for you.  If the value of these Interfaces changes (if the ambient temperature rises or falls for example) then your database will be kept up to date via the communications server without needing to sync the device instance going forward.
+
+### Building a Web Scaffold
+
+Now that you can communicate with your devices from the rails console, let's create a web scaffold so that you can communicate with them via your web browser.
+
+If you haven't done it already, run 
+
+```bash
+> rails generate simple_form:install
+```
+Then at the top of the config/initializers/simple_form.rb file put
+
+```ruby
+require 'simple_form'
+```
+
+To install the form helpers we will use to build forms to edit device interfaces via the browser.
+
+Once you've done that, you can run the apiotics scaffold controller generator to generate a scaffold and views for your device.
+
+```bash
+> rails generate apiotics:controller Thermostat
+```
+
+This command installs a default controller and views for your Thermostat.  Once they are installed, you can see them in your browser by starting up your development web server.
+
+```bash
+> rails server
+```
+
+Then in your web browser of choice, navigate to http://localhost:3000/thermostats.  This page will show you a list of your Thermostat instances, as well as the current values of the different interfaces for your device.  You can use the edit links for each device instance to change these values.
+
+### Adding Push Web Updates
+
+Since we want to be able to see changes to our devices without refreshing our webpage manually, we can leverage Rails 5's ActionCable to push device updates to our page.
+
+To do this, run:
+
+```bash
+> rails generate apiotics:channel Thermostat
+```
+
+This command installs a configuration file, in this case app/channels/thermostat_channel.rb, to define an ActionCable channel for your Worker, in this case thermostat_channel, as well as a coffeescript file, in this case app/assets/javascripts/channels/thermostat.coffee, that defines how the browser will update information from the server on the page.
+
+In order for the ActionCable messages to actually transmit to the browser, we need to install Redis.  Redis is an open source in-memory data store that ActionCable uses to implement its PubSub messaging.
+
+The easiest way to install Redis (if you are on a Mac) is:
+
+```bash
+> brew install redis
+```
+
+Then, once it is installed, run:
+
+```bash
+> redis-server
+```
+
+In your Rails application, edit your config/cable.yml file to look as follows:
+
+```yaml
+development:
+  adapter: redis
+
+test:
+  adapter: redis
+
+production:
+  adapter: redis
+```
+
+Add the following to your Gemfile:
+
+```ruby
+gem 'jquery-rails'
+```
+
+And run
+
+```bash
+> bundle install
+```
+
+Next, open up your app/assets/javascripts/application.js file.  Make sure you add the following lines to it above the require_tree . line, if you have it.
+
+```js
+//= require jquery
+//= require jquery_ujs
+```
+
+Then, restart your Rails server.  Once you have done that, the values on the Thermostats page will update via push notifications.
+
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Apiotics'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/apiotics.rb

@@ -0,0 +1,58 @@
+require 'apiotics/configuration'
+require "apiotics/version"
+require 'apiotics/server'
+require 'apiotics/client'
+require 'apiotics/parse'
+require 'apiotics/insert'
+require 'apiotics/extract'
+require 'apiotics/portal'
+require 'apiotics/hardware'
+require 'daemons'
+
+module Apiotics
+  
+  class << self
+    attr_accessor :configuration
+  end
+  
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+  
+  def self.reset
+    @configuration = Configuration.new
+  end
+  
+  def self.configure
+    yield(configuration)
+  end
+  
+  def self.get(object, time0= nil, time1= nil)
+    Apiotics::Extract.get(object, time0, time1)
+  end
+  
+  def self.get_attributes(parent_name, model_name)
+    configuration = Apiotics::Portal.retrieve_configuration
+    attributes = Apiotics::Portal.parse_drivers_and_scripts(configuration, parent_name, model_name)
+  end
+  
+  def self.sync_device_instances(worker_name, sync_data= false)
+    Apiotics::Portal.sync_device_instances(worker_name, sync_data)
+  end
+  
+  def self.sync(object)
+    parent = object.class.parent.name
+    child = object.class.name.demodulize
+    attributes = Apiotics.configuration.targets[parent][child]
+    interfaces = Hash.new
+    attributes.each do |attribute|
+      interfaces[attribute.underscore.downcase.gsub(" ", "_")] = object.send(attribute.underscore.downcase.gsub(" ", "_")).to_s
+    end
+    Apiotics::Extract.fire(object, interfaces, "get")
+  end
+  
+  def self.clear_settings
+    ApioticsSetting.destroy_all
+  end
+    
+end

data/lib/apiotics/client.rb

@@ -0,0 +1,20 @@
+# This class connects to the local server (see Server class).  Messages sent to the local server are forwarded.  The server class handles messages
+# received from the remote server.
+
+require "socket"
+module Apiotics
+  class Client
+    def initialize( server = 'localhost', port = Apiotics.configuration.local_port )
+      @server = server
+      @port = port
+    end
+
+    def send(msg)
+      connection = TCPSocket.open(@server, @port)
+      connection.puts( msg )
+      connection.close
+    end
+    
+  end
+
+end

data/lib/apiotics/configuration.rb

@@ -0,0 +1,23 @@
+module Apiotics
+  class Configuration
+  
+    attr_accessor :public_key, :private_key, :local_logging, :targets, :local_port, :server, :server_port, :portal, :push, :tls, :verify_peer, :handshake, :parents
+  
+    def initialize
+      @public_key = nil
+      @private_key = nil
+      @local_logging = true
+      @targets = nil
+      @local_port = 8001
+      @server = "rgs.microarx.com"
+      @server_port = 8000
+      @portal = "https://test.apiotics.com/"
+      @push = false
+      @tls = true
+      @verify_peer = true
+      @handshake = true
+      @parents = {}
+    end
+  
+  end
+end

data/lib/apiotics/extract.rb

@@ -0,0 +1,107 @@
+require 'json'
+
+module Apiotics
+  
+  class Extract
+    
+    def self.send(object)
+      interfaces = Hash.new
+      puts object.previous_changes
+      object.previous_changes.each do |k,v|
+        if Apiotics::Extract.is_target(object, k)
+          interfaces[k] = v[1].to_s
+        end
+      end
+      if interfaces != {}
+        Extract.fire(object, interfaces, "set-request")
+        if Apiotics.configuration.parents != {}
+        interfaces.each do |k,v|
+          if Apiotics.configuration.parents[object.class.parent.demodulize][object.class.demodulize][k] != nil
+            m =  "#{object.class.parent}".demodulize.underscore.gsub(" ","_").downcase
+            target_class = Apiotics.configuration.parents[object.class.parent.demodulize][object.class.demodulize][k]["driver"].downcase.constantize
+            target = object.m.target_class
+            i = Apiotics.configuration.parents[object.class.parent.demodulize][object.class.demodulize][k]["interface"].downcase.constantize
+            if Apiotics.configuration.parents[object.class.parent.demodulize][object.class.demodulize][k].keys < 3
+              target.i = v
+              target.skip_extract = true
+              target.save
+              target.skip_extract = false
+            else
+              target.i = Apiotics.configuration.parents[object.class.parent.demodulize][object.class.demodulize][k][v]
+              target.skip_extract = true
+              target.save
+              target.skip_extract = false
+            end
+          end
+        end
+      end
+    end
+    
+    def self.is_target(object, k)
+      if Apiotics.configuration.targets[object.class.parent.to_s][object.class.name.demodulize.to_s].include?(k) || Apiotics.configuration.targets[object.class.parent.to_s][object.class.name.demodulize.to_s].include?(k.titleize)
+        return true
+      else
+        return false
+      end
+    end
+    
+    def self.get(object, time0= nil, time1= nil)
+      object.accessed_fields.each do |field|
+        v = Array.new
+        if time0 != nil
+          Extract.fire(object, field, object.send(field), "get", time0, time1)
+        else
+          Extract.fire(object, field, object.send(field), "get")
+        end
+      end
+    end
+    
+    def self.fire(object, interfaces, a, time0= nil, time1= nil)
+      if Apiotics.configuration.targets[object.class.parent.to_s] != nil
+        k = "#{object.class.parent}::#{object.class.parent}".constantize
+        i = "#{object.class.parent}".demodulize.underscore.gsub(" ","_").downcase + "_id"
+        msg = {
+          "action" => a,
+          "instance" => k.find(object.send(i)).apiotics_instance,
+          "driver" => object.class.name.to_s,
+          "interface" => interfaces,
+        }
+        if time0 != nil
+          msg["time0"] = time0
+          msg["time1"] = time1
+        end
+        c = Apiotics::Client.new
+        c.send(msg.to_json)
+        object.skip_extract = true
+        interfaces.each do |key, value|
+          object.send(("#{key}_ack=").to_sym, false)
+          object.send(("#{key}_complete=").to_sym, false)
+          object.send(("#{key}_action=").to_sym, a)
+        end
+        object.save
+        object.skip_extract = false
+        unless Apiotics.configuration.local_logging == false
+          Extract.save_log(object, interfaces, a)
+        end
+      end
+    end
+    
+    
+    
+    def self.save_log(object, interfaces, a)
+      interfaces.each do |key, value|
+        klass = "#{object.class.name.underscore}_#{key}_log".classify.constantize
+        r = klass.new
+        r.send(("#{key}_action=").to_sym, a)
+        r.send(("#{key}=".to_sym), value)
+        r.send(("#{key}_ack=").to_sym, false)
+        r.send(("#{key}_complete=").to_sym, false)
+        r.send(("#{object.class.name.demodulize.underscore.gsub("/","_")}_id=").to_sym, object.id)
+        puts r.inspect
+        r.save
+      end
+    end
+
+  end
+  
+end