simbiotes 0.1.0

data/lib/generators/simbiotes/model/model_generator.rb

@@ -0,0 +1,58 @@
+module Simbiotes
+  class ModelGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :parent, :type => :string
+    argument :name, :type => :string
+    argument :attributes, :type => :hash, :required => false
+    
+    def run_generators
+      generate "simbiotes:create_table", arguments
+      if @c == nil
+        generate "simbiotes:create_model", "#{parent} #{name}"
+      else
+        generate "simbiotes:create_model", thorify
+        generate "simbiotes:initializer", "true"
+      end
+    end
+    
+    private
+    
+    def arguments
+      if attributes == nil
+        return get_attributes
+      else
+        return parent.to_s + " " + name.to_s + " " + stringify
+      end
+    end
+    
+    def stringify
+      string = String.new
+      attributes.each do |k,v|
+        string = string + k + ":" + v + " "
+      end
+      string
+    end
+    
+    def get_attributes
+      @c = Simbiotes.get_attributes(parent, name)
+      if @c[:kind] == "script"
+        generate "simbiotes:script", "#{parent} #{name}"
+      end
+      string = String.new
+      @c[:attributes].each do |k,v|
+        if v[:type] == "enum"
+          string = string + k.gsub(" ", "_").downcase + ":" + "integer" + " "
+        else
+          string = string + k.gsub(" ", "_").downcase + ":" + v[:type] + " "
+        end
+      end
+      return parent.to_s + " " + name.to_s + " " + string
+    end
+    
+    def thorify
+      string = String.new
+      string = parent.to_s + " " + name.to_s + " " + "true"
+    end
+    
+  end
+end

data/lib/generators/simbiotes/script/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generate a stub script to run on a device
+
+Example:
+    rails generate simbiotes:script Thing
+
+    This will create:
+        lib/scripts/simbiotes/thing.rb

data/lib/generators/simbiotes/script/script_generator.rb

@@ -0,0 +1,38 @@
+module Simbiotes
+  class ScriptGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :parent, :type => :string, :required => false
+    argument :name, :type => :string, :required => false
+  
+    def create_script
+      if name != nil
+        @c = Simbiotes::Portal.get_attributes(parent, name)
+        template "script.rb.erb", "lib/scripts/simbiotes/#{parent_file_name}/#{file_name}.rb"
+      end
+      copy_file "server.rb", "lib/scripts/server.rb"
+      copy_file "server_control.rb", "lib/scripts/server_control.rb"
+      copy_file "comm_server.rake", "lib/tasks/comm_server.rake"
+      copy_file "publish_script.rake", "lib/tasks/publish_script.rake"
+      FileUtils.chmod 0775, "lib/scripts/server_control.rb"
+    end
+  
+    private
+  
+    def file_name
+      name.underscore
+    end
+  
+    def class_name
+      name.classify
+    end
+    
+    def parent_class_name
+      parent.classify
+    end
+    
+    def parent_file_name
+      parent.underscore
+    end
+  
+  end
+end

data/lib/generators/simbiotes/script/templates/comm_server.rake

@@ -0,0 +1,19 @@
+namespace :comms do
+  desc "Start local communication server"
+  task start: :environment do
+    system("ruby", "#{Rails.root}/lib/scripts/server_control.rb", "start")
+    puts $?
+  end
+
+  desc "Stop local communication server"
+  task stop: :environment do
+    system("ruby", "#{Rails.root}/lib/scripts/server_control.rb", "stop")
+    puts $?
+  end
+  
+  desc "Restart local communication server"
+  task restart: :environment do
+    system("ruby", "#{Rails.root}/lib/scripts/server_control.rb", "restart")
+    puts $?
+  end
+end

data/lib/generators/simbiotes/script/templates/publish_script.rake

@@ -0,0 +1,6 @@
+namespace :script do
+  desc "Publish script to the hive."
+  task :publish, [:worker, :name] => [:environment] do |task, args|
+    Simbiotes::Portal.upload_script(args[:worker], args[:name])
+  end
+end

data/lib/generators/simbiotes/script/templates/script.rb.erb

@@ -0,0 +1,12 @@
+#######
+# This script will be deployed to your device.
+# The $global variables below represent the values your script will receive/needs to provide to/from its various interfaces and inputs.
+# Your script should change the value of these variables to what they should be, and they will then get passed back.
+# You can also add additional global variables.  If you do, these will be passed back to the script along with the 
+# interface and input variables the next time the script is invoked.  These are useful for keeping state across script 
+# invocations.
+<% @c[:attributes].each do |k,v|%>
+  $<%= k.gsub(" ","_") %><% end %><% @c[:inputs].each do |k,v|%>
+  $<%= "#{k.gsub(" ","_")}_#{v.gsub(" ","_")}" %><% end %>
+
+# put your logic here.

data/lib/generators/simbiotes/script/templates/server.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# Load Rails
+ENV['RAILS_ENV'] = ARGV[0] || 'production'
+DIR = File.dirname(__FILE__) 
+require DIR + '/../../config/environment'
+
+Simbiotes::Server.new

data/lib/generators/simbiotes/script/templates/server_control.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# add the ontop: true option to see the output of the server in the console in which you run rake comms:start
+
+require 'daemons'
+
+Daemons.run('lib/scripts/server.rb', ontop: false)

data/lib/simbiotes/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 Simbiotes
+  class Client
+    def initialize( server = 'localhost', port = Simbiotes.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/simbiotes/configuration.rb

@@ -0,0 +1,18 @@
+module Simbiotes
+  class Configuration
+  
+    attr_accessor :public_key, :private_key, :local_logging, :targets, :local_port, :server, :server_port, :portal
+  
+    def initialize
+      @public_key = nil
+      @private_key = nil
+      @local_logging = true
+      @targets = nil
+      @local_port = 8001
+      @server = "rgs.microarx.com"
+      @server_port = 8000
+      @portal = "http://www.simbiotes.com/"
+    end
+  
+  end
+end

data/lib/simbiotes/extract.rb

@@ -0,0 +1,75 @@
+require 'json'
+
+module Simbiotes
+  
+  class Extract
+    
+    def self.send(object)
+      interfaces = Hash.new
+      puts object.previous_changes
+      object.previous_changes.each do |k,v|
+        if Simbiotes.configuration.targets[object.class.parent.to_s][object.class.name.demodulize.to_s].include?(k) || Simbiotes.configuration.targets[object.class.parent.to_s][object.class.name.demodulize.to_s].include?(k.titleize)
+          interfaces[k] = v[1].to_s
+        end
+      end
+      if interfaces != {}
+        Extract.fire(object, interfaces, "set-request")
+      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 Simbiotes.configuration.targets[object.class.parent.to_s] != nil
+        msg = {
+          "action" => a,
+          "instance" => object.simbiotes_instance,
+          "driver" => object.class.name.to_s,
+          "interface" => interfaces,
+        }
+        if time0 != nil
+          msg["time0"] = time0
+          msg["time1"] = time1
+        end
+        c = Simbiotes::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
+        Extract.save_log(object, interfaces, a)
+      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

data/lib/simbiotes/insert.rb

@@ -0,0 +1,89 @@
+# This class takes ruby hashes and saves them to the appropriate database table.
+# All model methods that have corresponding IoT interfaces have six database fields associated with them.
+# The first is a field named the same as the method.  The second is name_ack, and third is name_complete, the fourth is name_timestamp, the fifth is name_status, the sixth is name_action.
+# In the hash, instance is the record id (not necessarily the id column), driver is the model, interface is the method.
+# Data should be saved both to the model's database table and to the corresponding log table (name_method_logs).
+
+module Simbiotes
+  class Insert
+    def initialize(hash = {"action" => "set-complete", "instance" => 1, "driver" => "test_driver", "interface" => "control", "value" => 72, "timestamp" => "1000000000000", "status" => "ok"})
+      @action = hash["action"]
+      @id = hash["instance"]
+      @class = hash["driver"]
+      @methods = hash["interface"]
+      @value = hash["value"]
+      @timestamp = hash["timestamp"]
+      @status = hash["status"]
+      find_record
+      @methods.each do |k,v|
+        @record.send(("#{k}_action=").to_sym, @action)
+        @record.send("#{k}=".to_sym, @value)
+        @record.send("#{k}_timestamp=".to_sym, @timestamp)
+        @record.send("#{k}_status=".to_sym, @status)
+      end
+      if @action == "set-complete"
+        set_complete
+      elsif @action == "set-request-ack"
+        set_ack
+      elsif @action == "get-ack"
+        get_ack
+      end
+    end
+    
+    def find_record
+      begin
+        klass = @class.classify.constantize
+        @record = klass.find_by(simbiotes_instance: @id)
+      rescue => e
+        puts e
+      end
+    end
+    
+    def set_ack
+      @methods.each do |k,v|
+        @record.send("#{k}_ack=".to_sym, true)
+        @record.send("#{k}_complete=".to_sym, false)
+      end
+    end
+    
+    def set_complete
+      @methods.each do |k,v|
+        @record.send("#{k}_ack=".to_sym, true)
+        @record.send("#{k}_complete=".to_sym, true)
+      end
+    end
+    
+    def get_ack
+      @methods.each do |k,v|
+        @record.send("#{k}_ack=".to_sym, true)
+        @record.send("#{k}_complete=".to_sym, false)
+      end
+    end
+
+    def save
+      @record.skip_extract = true
+      @record.save
+      @record.skip_extract = false
+    end
+    
+    def action
+      @action.to_s
+    end
+    
+    def save_log
+      @methods.each do |k,v|
+        klass = "#{@class}_#{k}_log".classify.constantize
+        r = klass.new
+        r.send(("#{k}_action=").to_sym, @action)
+        r.send("#{k}=".to_sym, v)
+        r.send("#{k}_timestamp=".to_sym, @timestamp)
+        r.send("#{k}_status=".to_sym, @status)
+        r.send("#{k}_ack=".to_sym, @record.send("#{k}_ack"))
+        r.send("#{k}_complete=".to_sym, @record.send("#{k}_complete"))
+        r.send("#{@class.classify.demodulize.underscore.gsub("/","_")}_id=".to_sym, @record.id)
+        r.save
+      end
+    end
+    
+  end
+end

data/lib/simbiotes/parse.rb

@@ -0,0 +1,20 @@
+# This class is responsible for parsing JSON messages and configuration files into ruby hashes.
+
+require 'json'
+
+module Simbiotes
+  class Parse
+    
+    def self.message(string)
+      JSON.parse(string)
+    end
+    
+    def self.config(string)
+      JSON.parse(string)
+    end
+    
+    def self.portal(string)
+      JSON.parse(string)
+    end
+  end
+end

data/lib/simbiotes/portal.rb

@@ -0,0 +1,127 @@
+
+require 'httparty'
+require 'rest-client'
+
+module Simbiotes
+  class Portal
+    
+    def self.get_attributes(parent_name, model_name)
+      configuration = Portal.retrieve_configuration
+      attributes = Portal.parse_drivers_and_scripts(configuration, parent_name, model_name)
+    end
+    
+    def self.parse_drivers_and_scripts(hash, parent_name, model_name)
+      attributes_hash = nil
+      hash["workers"][parent_name]["drivers"].each do |k,v|
+        name = v["metadata"]["common name"].classify
+        if name == model_name.classify
+          attributes_hash = Hash.new
+          attributes_hash[:kind] = "driver"
+          attributes_hash[:attributes] = Hash.new
+          v["interfaces"].each do |k,v|
+            attributes_hash[:attributes][k] = {
+              type: v["type"],
+              accessor: v["accessor type"],
+              units: v["units"],
+              noise: v["noise threshold"],
+              values: v["values"],
+              range: v["range"]
+            }
+          end
+        end     
+      end
+      hash["workers"][parent_name]["scripts"].each do |k,v|
+        name = v["metadata"]["common name"].classify
+        if name == model_name.classify
+          attributes_hash = Hash.new
+          attributes_hash[:kind] = "script"
+          attributes_hash[:attributes] = Hash.new
+          v["interfaces"].each do |key,value|
+            attributes_hash[:attributes][key] = {
+              type: value["type"],
+              accessor: value["accessor type"],
+              units: value["units"],
+              noise: value["noise threshold"],
+              values: value["values"],
+              range: value["range"]
+            }
+          end
+          attributes_hash[:inputs] = Hash.new
+          v["inputs"].each do |key,value|
+            attributes_hash[:inputs][key] = value
+          end
+        end
+      end
+      return attributes_hash
+    end
+    
+    def self.retrieve_configuration
+      json = HTTParty.post("#{Simbiotes.configuration.portal}api/hive", :query => {:public_key => Simbiotes.configuration.public_key, :private_key => Simbiotes.configuration.private_key}).body
+      hash = Simbiotes::Parse.portal(json)
+    end
+    
+    def self.parse_all_interfaces
+      configuration = Portal.retrieve_configuration
+      hash = Hash.new
+      configuration["workers"].each do |key, value|
+        hash[key] = Hash.new
+        configuration["workers"][key]["drivers"].each do |k,v|
+          a = Array.new
+          if v["interfaces"] != nil
+            v["interfaces"].each do |key, value|
+              a << key
+            end
+          end
+          hash[key][v["metadata"]["common name"]] = a
+        end
+        configuration["workers"][key]["scripts"].each do |k,v|
+          a = Array.new
+          if v["interfaces"] != nil
+            v["interfaces"].each do |key, value|
+              a << key
+            end
+          end
+          hash[key][v["metadata"]["common name"]] = a
+        end
+      end
+      hash
+    end
+      
+    def self.sync_device_instances(worker_name)
+      instance_hash = JSON.parse(HTTParty.post("#{Simbiotes.configuration.portal}api/workers", :query => {:public_key => Simbiotes.configuration.public_key, :private_key => Simbiotes.configuration.private_key}).body)
+      Simbiotes.configuration.targets[worker_name].keys.each do |key|
+        klass = (worker_name + "::" + key).constantize rescue nil
+        unless klass == nil
+          instance_ids = Array.new
+          instance_hash[worker_name].each do |instance_id,status|
+            instance_ids << instance_id
+          end
+          stale_instances = klass.where.not(simbiotes_instance: instance_ids)
+          stale_instances.destroy_all
+          instance_ids.each do |instance_id|
+            i = klass.find_by(simbiotes_instance: instance_id)
+            if i == nil
+              i = klass.new
+              i.simbiotes_instance = instance_id
+              i.skip_extract = true
+              i.save(:validate => false)
+              i.skip_extract = false
+            end 
+          end
+        end
+      end
+    end
+  
+    def self.upload_script(worker, script)
+      payload = {
+        :multipart => true,
+        :script_file => File.open("#{Rails.root}/lib/scripts/simbiotes/#{worker.downcase}/#{script.downcase}.rb", 'rb'),
+        :public_key => Simbiotes.configuration.public_key,
+        :private_key => Simbiotes.configuration.private_key,
+        :worker_name => worker,
+        :script_name => script
+      }
+      r = RestClient.post("#{Simbiotes.configuration.portal}api/upload_script", payload)
+    end
+  end
+end

data/lib/simbiotes/railtie.rb

@@ -0,0 +1,14 @@
+require 'simbiotes'
+require 'rails'
+
+module Simbiotes
+  class Railtie < Rails::Railtie
+    generators do
+      require 'lib/generators/simbiotes/model'
+      require 'lib/generators/simbiotes/create_table'
+      require 'lib/generators/simbiotes/create_model'
+      require 'lib/generators/simbiotes/initializer'
+      require 'lib/generators/simbiotes/migration'
+    end
+  end
+end

data/lib/simbiotes/server.rb

@@ -0,0 +1,66 @@
+
+# This class creates a local server listening on port 8001, and connects to a remote server on port 8000.  Messages sent to the local server are transmitted
+# to the remote server.  Messages received from the remote server are forwarded to the appropriate logic.
+
+require "socket"
+module Simbiotes
+  class Server
+    def initialize( server = TCPSocket.open( Simbiotes.configuration.server, Simbiotes.configuration.server_port ) )
+      @server = server
+      @localport = Simbiotes.configuration.local_port
+      listen_remote
+      listen_local
+    end
+
+    def send(msg)
+      puts "Message sent: #{msg}"
+      @server.puts( msg )
+    end
+    
+    def close
+      @server.close
+    end
+    
+    def listen_remote
+      begin
+        Thread.new do
+          loop do
+        	  msg = @server.gets
+        	  puts msg
+            msg_hash = Simbiotes::Parse.message(msg)
+            r = Simbiotes::Insert.new(msg_hash)
+            puts "Message received": msg_hash
+            if r.action == "set-request-ack" || r.action == "set-complete" || r.action == "get-ack"
+              r.save
+              unless Simbiotes.configuration.local_logging == false
+                r.save_log
+              end
+            end
+          end
+        end
+      rescue => e
+        puts e
+        listen_remote
+      end
+      
+    end
+    
+    def listen_local
+      begin
+        server = TCPServer.open(@localport)
+        loop do
+        	Thread.fork(server.accept) do |client| 
+        		s = client.gets
+        		#puts s
+        		self.send(s)
+        	end
+        end
+      rescue => e
+        puts e
+        listen_local
+      end
+    end
+    
+  end
+
+end

data/lib/simbiotes/version.rb

@@ -0,0 +1,3 @@
+module Simbiotes
+  VERSION = '0.1.0'
+end

data/lib/simbiotes.rb

@@ -0,0 +1,52 @@
+require 'simbiotes/configuration'
+require "simbiotes/version"
+require 'simbiotes/server'
+require 'simbiotes/client'
+require 'simbiotes/parse'
+require 'simbiotes/insert'
+require 'simbiotes/extract'
+require 'simbiotes/portal'
+require 'daemons'
+
+module Simbiotes
+  
+  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)
+    Simbiotes::Extract.get(object, time0, time1)
+  end
+  
+  def self.get_attributes(parent_name, model_name)
+    configuration = Simbiotes::Portal.retrieve_configuration
+    attributes = Simbiotes::Portal.parse_drivers_and_scripts(configuration, parent_name, model_name)
+  end
+  
+  def self.sync_device_instances(worker_name)
+    Simbiotes::Portal.sync_device_instances(worker_name)
+  end
+  
+  def self.sync(object)
+    parent = object.class.parent.name
+    child = object.class.name.demodulize
+    attributes = Simbiotes.configuration.targets[parent][child]
+    interfaces = Hash.new
+    attributes.each do |attribute|
+      interfaces[attribute.downcase.gsub(" ", "_")] = object.send(attribute.downcase.gsub(" ", "_"))
+    end
+    Simbiotes::Extract.fire(object, interfaces, "get")
+  end
+end

data/lib/tasks/simbiotes_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+
+#task :simbiotes do
+#end