apiotics-test 0.1.49

data/lib/apiotics/hardware.rb

@@ -0,0 +1,109 @@
+require 'os'
+
+module Apiotics
+  class Hardware
+    def self.bits
+      OS.bits
+    end
+    
+    def self.linux
+      OS.linux?
+    end
+    
+    def self.mac
+      OS.mac?
+    end
+    
+    def self.save_openocd
+      os = nil
+      if self.linux == true 
+        if self.bits == 64
+          os = "debian64"
+        elsif self.bits == 32
+          os = "debian32"
+        end
+      elsif self.mac == true
+        os = "mac"
+      end
+      unless os == nil
+        data = Apiotics::Portal.openocd(os)
+        directory = Rails.root.join('lib', 'openocd')
+        Dir.mkdir directory unless Dir.exist?(directory)
+        path = Rails.root.join('lib', 'openocd', 'openocd.tgz')
+        file = File.new(path, 'w')
+        file.write data.force_encoding(Encoding::UTF_8)
+        file.close
+      end
+    end
+    
+    def self.unpack_openocd
+      directory = Rails.root.join('lib', 'openocd')
+      Dir.chdir directory
+      path = Rails.root.join('lib', 'openocd', 'openocd.tgz')
+      msg = system("tar -xvzf #{path}")
+      if msg == true
+        File.delete(path) if File.exist?(path)
+      end
+    end
+    
+    def self.install_firmware(config_script, firmware_path, starting_address)
+      directory = Rails.root.join('lib', 'openocd', 'gnuarmeclipse')
+      unless Dir.exist?(directory)
+        self.save_openocd
+        self.unpack_openocd
+      end
+      directory = Rails.root.join('lib', 'openocd', 'gnuarmeclipse', 'openocd')
+      Dir.chdir directory
+      version_folder = Dir['*/'].first[0..-2]
+      directory = Rails.root.join('lib', 'openocd', 'gnuarmeclipse', 'openocd', version_folder)
+      Dir.chdir directory
+      string = "bin/openocd -f \"scripts/board/" + config_script + "\"" + " -c \"program " + firmware_path.to_s + " exit " + starting_address.to_s + "\""
+      msg = system(string)
+    end
+    
+    def self.openocd(worker_name, name)
+      download_directory = Rails.root.join('lib', 'openocd')
+      Dir.mkdir download_directory unless Dir.exist?(download_directory)
+      download_directory = Rails.root.join('lib', 'openocd', 'downloads')
+      Dir.mkdir download_directory unless Dir.exist?(download_directory)
+      Dir.chdir download_directory
+      config = Apiotics::Portal.openocd_worker_config(worker_name)
+      config = JSON.parse(config)
+      unless config["openocd_config_file_name"] == nil || config["openocd_config_file_name"] == ""
+        path = Rails.root.join('lib', 'openocd', 'downloads', config["firmware_file_name"])
+        if File.exist?(path)
+        else
+          firmware_data = Apiotics::Portal.download_firmware(worker_name)
+          file = File.new(path, 'w')
+          file.write firmware_data.force_encoding(Encoding::UTF_8)
+          file.close
+        end
+        clean_string = "1" * 68 * 8
+        clean = Array.new
+        clean[0] = clean_string
+        clean_bits = clean.pack("B*")
+        if name != nil
+          if name.length > 64
+            name = name[0..63]
+          end
+          data = File.open(path, 'r+')
+          version_offset = 2048
+          offset = version_offset + 4 + 68 + 68 + 68
+          IO.write(data, clean_bits.force_encoding(Encoding::UTF_8), offset)
+          name = name + "\0"
+          IO.write(data, name, offset)
+          data.close
+        else
+          data = File.open(path, 'r+')
+          version_offset = 2048
+          offset = version_offset + 4 + 68 + 68 + 68
+          IO.write(data, clean_bits.force_encoding(Encoding::UTF_8), offset)
+          data.close
+        end
+        msg = self.install_firmware(config["openocd_config_file_name"], path, config["openocd_start_address"])
+      end
+      return msg
+    end
+    
+  end
+end

data/lib/apiotics/insert.rb

@@ -0,0 +1,115 @@
+# 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"]
+      @valid = true
+      begin
+        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
+      rescue
+        @valid = false
+      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)
+      rescue Exception => e
+        puts e.to_s
+      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 valid
+      return @valid
+    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,217 @@
+
+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.parse_parents
+      configuration = Portal.retrieve_configuration
+      hash = Hash.new
+      configuration["workers"].each do |key, value|
+        if hash[key] == nil
+          hash[key] = Hash.new
+        end
+        value["drivers"].each do |k, v|
+          if hash[key][k] == nil
+            hash[key][k] = Hash.new
+          end
+          if v["parents"] != {}
+            v["parents"].each do |parent_driver, parent_hash|
+              parent_hash.each do |parent_interface, parent_value|
+                if parent_value.is_a? Hash
+                  hash[key][k][parent_value["interface"]] = Hash.new
+                  hash[key][k][parent_value["interface"]]["interface"] = parent_interface
+                  hash[key][k][parent_value["interface"]]["driver"] = parent_driver
+                  if hash[key][parent_driver] == nil
+                    hash[key][parent_driver] = Hash.new
+                    hash[key][parent_driver][parent_interface] = Hash.new
+                  end
+                  hash[key][parent_driver][parent_interface]["interface"] = parent_value["interface"]
+                  hash[key][parent_driver][parent_interface]["driver"] = k
+                  if parent_value.keys.count > 2
+                    parent_value.each do |pv_key, pv_value|
+                      unless pv_key == "interface"
+                        hash[key][parent_driver][parent_interface][pv_key] = pv_value
+                        hash[key][k][parent_value["interface"]][pv_value] = pv_key
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end 
+      end
+      hash
+    end
+      
+    def self.sync_device_instances(worker_name, sync_data)
+      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 = Hash.new
+        instance_id_array = Array.new
+        instance_hash[worker_name].each do |instance_id,status_hash|
+          if status_hash["status"] == "Active"
+            instance_ids[instance_id] = status_hash
+            instance_id_array << instance_id
+          end
+        end
+        stale_instances = klass.where.not(apiotics_instance: instance_id_array)
+        stale_instances.destroy_all
+        instance_ids.each do |instance_id, status_hash|
+          i = klass.find_by(apiotics_instance: instance_id)
+          if i == nil
+            i = klass.new
+            i.apiotics_instance = instance_id
+            i.name = status_hash["name"]
+            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
+                if sync_data == true
+                  s.sync
+                end
+                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
+    
+    def self.openocd(system)
+      response = HTTParty.post("#{Apiotics.configuration.portal}api/openocd", :query => {:public_key => Apiotics.configuration.public_key, :private_key => Apiotics.configuration.private_key, :system => system}).body
+    end
+    
+    def self.openocd_worker_config(worker_name)
+      response = HTTParty.post("#{Apiotics.configuration.portal}api/openocd_details", :query => {:public_key => Apiotics.configuration.public_key, :private_key => Apiotics.configuration.private_key, :worker => worker_name}).body
+    end
+    
+    def self.download_firmware(worker_name)
+      response = HTTParty.post("#{Apiotics.configuration.portal}api/download", :query => {:public_key => Apiotics.configuration.public_key, :private_key => Apiotics.configuration.private_key, :worker => worker_name}).body
+    end
+    
+  end
+end