apiotics 0.1.22

data/lib/apiotics/insert.rb

@@ -0,0 +1,105 @@
+# 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 Apiotics
+  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)
+        @type = @record.class.columns_hash[k].type
+        #change_value
+        @record.send("#{k}=".to_sym, v)
+        @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
+        master_klass = (klass.parent.to_s + "::" + klass.parent.to_s).classify.constantize
+        master_record = master_klass.find_by(apiotics_instance: @id)
+        @record = master_record.send(@class.demodulize.underscore.downcase)
+        #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
+    
+    def change_value
+      if @type == :boolean
+        if @value == "true"
+          @value = true
+        elsif @value == "false"
+          @value = false
+        end
+      elsif @type == :integer
+        @value = @value.to_i
+      elsif @type == :string
+      end
+    end
+    
+  end
+end

data/lib/apiotics/parse.rb

@@ -0,0 +1,20 @@
+# This class is responsible for parsing JSON messages and configuration files into ruby hashes.
+
+require 'json'
+
+module Apiotics
+  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/apiotics/portal.rb

@@ -0,0 +1,156 @@
+
+require 'httparty'
+require 'rest-client'
+
+module Apiotics
+  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("#{Apiotics.configuration.portal}api/hive", :query => {:public_key => Apiotics.configuration.public_key, :private_key => Apiotics.configuration.private_key}).body
+      hash = Apiotics::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("#{Apiotics.configuration.portal}api/workers", :query => {:public_key => Apiotics.configuration.public_key, :private_key => Apiotics.configuration.private_key}).body)      
+      klass = (worker_name.to_s + "::" + worker_name.to_s).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(apiotics_instance: instance_ids)
+        stale_instances.destroy_all
+        instance_ids.each do |instance_id|
+          i = klass.find_by(apiotics_instance: instance_id)
+          if i == nil
+            i = klass.new
+            i.apiotics_instance = instance_id
+            i.save(:validate => false)
+            Apiotics.configuration.targets[worker_name].keys.each do |key|
+              subklass = (worker_name + "::" + key).constantize rescue nil
+              unless subklass == nil
+                s = subklass.new
+                k = worker_name.underscore.gsub(" ","_").to_s + "_id="
+                s.send((k).to_sym, i.id)
+                s.skip_extract = true
+                s.save(:validate => false)
+                s.skip_extract = false
+              end
+            end 
+          end
+        end
+      end
+    end
+  
+    def self.upload_script(worker, script)
+      payload = {
+        :multipart => true,
+        :script_file => File.open("#{Rails.root}/lib/scripts/apiotics/#{worker.underscore.downcase}/#{script.underscore.downcase}.rb", 'rb'),
+        :public_key => Apiotics.configuration.public_key,
+        :private_key => Apiotics.configuration.private_key,
+        :worker_name => worker,
+        :script_name => script
+      }
+      r = RestClient.post("#{Apiotics.configuration.portal}api/upload_script", payload)
+    end
+    
+    def self.generate_certificate(csr)
+      csr_file = Tempfile.new
+      csr_file.write(csr)
+      csr_file.rewind
+      payload = {
+        :multipart => true,
+        :csr => csr_file,
+        :public_key => Apiotics.configuration.public_key,
+        :private_key => Apiotics.configuration.private_key
+      }
+      r = RestClient.post("#{Apiotics.configuration.portal}api/generate_certificate", payload)
+      instance_hash = JSON.parse(r.body)
+      return instance_hash["certificate"]
+    end
+    
+    def self.ca_certificate
+      response = HTTParty.post("#{Apiotics.configuration.portal}api/ca_certificate", :query => {:public_key => Apiotics.configuration.public_key, :private_key => Apiotics.configuration.private_key}).body
+      hash = JSON.parse(response)
+      return hash["ca_certificate"]
+    end
+    
+  end
+end

data/lib/apiotics/railtie.rb

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

data/lib/apiotics/server.rb

@@ -0,0 +1,236 @@
+
+# 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"
+require 'openssl'
+require 'json'
+
+module Apiotics
+  class Server
+    def initialize
+        @error_msg = nil
+        server_details = Server.lookup
+        rgs = ApioticsSetting.find_by(key: "server")
+        rgs_port = ApioticsSetting.find_by(key: "port")
+        if rgs == nil
+          if server_details["status"] == "ok"
+            rgs = server_details["ip"]
+            c = ApioticsSetting.new
+            c.key = "server"
+            c.value = rgs
+            c.save
+            rgs_port = server_details["port"]
+            c = ApioticsSetting.new
+            c.key = "port"
+            c.value = rgs_port
+            c.save
+          else
+            @error_msg = server_details["status_msg"]
+          end
+        else
+          if server_details["status"] == "ok"
+            rgs.value = server_details["ip"]
+            rgs.save
+            rgs = rgs.value
+            rgs_port.value = server_details["port"]
+            rgs_port.save
+            rgs_port = rgs_port.value
+          else
+            @error_msg = server_details["status_msg"]
+          end
+        end
+      if Apiotics.configuration.tls == true
+        socket = TCPSocket.new(rgs, rgs_port)
+        context = OpenSSL::SSL::SSLContext.new
+        context.key = Server.key
+        context.cert = Server.cert
+        if Apiotics.configuration.verify_peer == true
+          ca_tempfile = Tempfile.new
+          ca_tempfile.write Server.ca_cert.to_pem
+          ca_tempfile.rewind
+          context.ca_file = ca_tempfile.path
+          context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+        server = OpenSSL::SSL::SSLSocket.new socket, context
+        server.sync_close = true
+        server.connect
+        if Apiotics.configuration.verify_peer == true
+          ca_tempfile.close(true)
+        end
+      else
+        server = TCPSocket.open(rgs, rgs_port)
+      end
+      @server = server
+      @localport = Apiotics.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 = Apiotics::Parse.message(msg)
+            r = Apiotics::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 Apiotics.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)
+        if Apiotics.configuration.handshake == true
+          self.send('{"action":"connect"}')
+        end
+        loop do
+        	Thread.fork(server.accept) do |client| 
+        		s = client.gets
+        		if @error_msg != nil
+        		  string = '{"error":"' + error_msg + '"}'
+        		  client.puts(string)
+        		end
+        		#puts s
+        		self.send(s)
+        	end
+        end
+      rescue => e
+        puts e
+        listen_local
+      end
+    end
+    
+    def self.lookup
+      if Apiotics.configuration.tls == true
+        socket = TCPSocket.new(Apiotics.configuration.server, Apiotics.configuration.server_port)
+        context = OpenSSL::SSL::SSLContext.new
+        context.key = Server.key
+        context.cert = Server.cert
+        if Apiotics.configuration.verify_peer == true
+          ca_tempfile = Tempfile.new
+          ca_tempfile.write Server.ca_cert.to_pem
+          ca_tempfile.rewind
+          context.ca_file = ca_tempfile.path
+          context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+        server = OpenSSL::SSL::SSLSocket.new socket, context
+        server.sync_close = true
+        server.connect
+      else
+        server = TCPSocket.open(Apiotics.configuration.server, Apiotics.configuration.server_port)
+      end
+      server.puts('{"action":"lookup"}')
+      msg = server.gets
+      hash = JSON.parse(msg)
+      server.close
+      if Apiotics.configuration.verify_peer == true
+        ca_tempfile.close(true)
+      end
+      return hash
+    end
+    
+    def self.key
+      key = ApioticsSetting.find_by(key: "key")
+      if key == nil
+        key = Server.generate_key
+      else
+        key = key.value
+      end
+      pass_phrase = ApioticsSetting.find_by(key: "key_pass_phrase").value
+      key = OpenSSL::PKey::RSA.new key, pass_phrase
+      return key
+    end
+    
+    def self.cert
+      cert = ApioticsSetting.find_by(key: "cert")
+      if cert == nil
+        key = Server.key
+        public_key = key.public_key
+        cert = Server.generate_cert(key, public_key)
+        c = ApioticsSetting.new
+        c.key = "cert"
+        c.value = cert
+        c.save
+      else
+        cert = cert.value
+      end
+      cert = OpenSSL::X509::Certificate.new cert
+      return cert
+    end
+    
+    def self.generate_key
+      key = OpenSSL::PKey::RSA.new 2048
+      pass_phrase = 'simbiotes'
+      cipher = OpenSSL::Cipher.new 'AES-128-CBC'
+      s = ApioticsSetting.new
+      s.key = "key_cipher"
+      s.value = "OpenSSL::Cipher.new 'AES-128-CBC'"
+      s.save
+      s = ApioticsSetting.new
+      s.key = "key_pass_phrase"
+      s.value = 'simbiotes'
+      s.save
+      s = ApioticsSetting.new
+      s.key = "public_key"
+      s.value = key.public_key.to_pem
+      s.save
+      s = ApioticsSetting.new
+      s.key = "key"
+      s.value = key.export(cipher, pass_phrase)
+      s.save
+      return s.value
+    end
+    
+    def self.generate_cert(key, public_key)
+      csr = OpenSSL::X509::Request.new
+      csr.version = 0
+      csr.subject = OpenSSL::X509::Name.parse "CN=simbiotes.com/O=#{Apiotics.configuration.public_key}/OU=#{Apiotics.configuration.private_key}"
+      csr.public_key = key.public_key
+      csr.sign key, OpenSSL::Digest::SHA1.new
+      cert = Apiotics::Portal.generate_certificate(csr)
+      return cert
+    end
+    
+    def self.ca_cert
+      ca_cert = ApioticsSetting.find_by(key: "ca_cert")
+      if ca_cert == nil
+        ca_cert = Apiotics::Portal.ca_certificate
+        c = ApioticsSetting.new
+        c.key = "ca_cert"
+        c.value = ca_cert
+        c.save
+      else
+        ca_cert = ca_cert.value
+      end
+      ca_cert = OpenSSL::X509::Certificate.new ca_cert
+      return ca_cert
+    end
+    
+    def do_at_exit
+    end
+    
+  end
+end