apiotics 0.1.141 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3234b0c682cfe652ef3e745c6b4b3f9e96fb869e
-  data.tar.gz: b0c7352caa5bd5387c293bab331db8a589bd8953
+  metadata.gz: 185f239908233c662b8a5abccb2ae33dedc35ccb
+  data.tar.gz: '08ffbf5c91966a2923a9d03bebf966b3c4fadbb8'
 SHA512:
-  metadata.gz: 0cc4bbc8b7c956c73a464d640e3a158db671a663a1c30c3dedc864d9b30b504239015de9771314685b94c5aaf99939ffded9145027ad762f2969974684f5d3e3
-  data.tar.gz: 364f8457d2349f2bef39997f41cfa5c94c782aac336967a12a44d9b16e0d69210d59f38a274b59338ed5cd838203348c35c79faff0fb66c919db3efa5fad4424
+  metadata.gz: 656e760acebbc1ca43fd5c6b0e5f01c82815e4004a1dee246793a3ad0964fd4393a0465324075a573b489154350d8d50167a2beea7e816df9d140b7c3a9b04c2
+  data.tar.gz: cca8670e92c02c334c731b0a0babd0bc3037d494b6663777613b2c59ff8c231a24f1a5aa9a470eba36fd205385f978b399c339a76801dcaaa7f37cecbdf141ca

data/lib/apiotics.rb

@@ -8,6 +8,7 @@ require 'apiotics/extract'
 require 'apiotics/portal'
 require 'apiotics/hardware'
 require 'apiotics/connection_error'
+require 'apiotics/encrypt_decrypt'
 require 'daemons'
 
 module Apiotics

data/lib/apiotics/configuration.rb

@@ -1,7 +1,7 @@
 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, :reduced_metadata, :redis_comms_connection, :interface_kinds, :max_missed_heartbeats, :heartbeat_interval, :heroku, :create_heartbeat_error
+    attr_accessor :public_key, :private_key, :local_logging, :targets, :local_port, :server, :server_port, :portal, :push, :tls, :verify_peer, :handshake, :parents, :reduced_metadata, :redis_comms_connection, :interface_kinds, :max_missed_heartbeats, :heartbeat_interval, :heroku, :server_type, :mqtt_port, :aws_endpoint, :create_heartbeat_error
   
     def initialize
       @public_key = nil
@@ -23,6 +23,9 @@ module Apiotics
       @heartbeat_interval = 5
       @create_heartbeat_error = false
       @heroku = false
+      @server_type = nil
+      @mqtt_port = 8883
+      @aws_endpoint
       @interface_kinds = {
         "string" => "string",
         "text" => "string",

data/lib/apiotics/encrypt_decrypt.rb

@@ -0,0 +1,19 @@
+require 'openssl'
+
+class String
+  def apiotics_encrypt(key)
+    cipher = OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+    cipher.key = Digest::SHA1.hexdigest key
+    s = cipher.update(self) + cipher.final
+
+    s.unpack('H*')[0].upcase
+  end
+
+  def apiotics_decrypt(key)
+    cipher = OpenSSL::Cipher.new('DES-EDE3-CBC').decrypt
+    cipher.key = Digest::SHA1.hexdigest key
+    s = [self].pack("H*").unpack("C*").pack("c*")
+
+    cipher.update(s) + cipher.final
+  end
+end

data/lib/apiotics/extract.rb

@@ -9,7 +9,7 @@ module Apiotics
       puts object.previous_changes
       object.previous_changes.each do |k,v|
         if Apiotics::Extract.is_target(object, k)
-          interfaces[k] = v[1].to_s
+          interfaces[k] = v[1]
         end
       end
       if interfaces != {}

data/lib/apiotics/hardware.rb

@@ -1,5 +1,6 @@
 require 'os'
 require 'etc'
+require 'json'
 
 module Apiotics
   class Hardware
@@ -59,7 +60,7 @@ module Apiotics
       end
     end
     
-    def self.install_firmware(config_script, firmware_path, starting_address)
+    def self.openocd_install_firmware(config_script, firmware_path, starting_address)
       directory = Rails.root.join('lib', 'openocd', 'gnuarmeclipse')
       unless Dir.exist?(directory)
         self.save_openocd
@@ -74,19 +75,19 @@ module Apiotics
       msg = system(string)
     end
     
-    def self.openocd(worker_name, name)
+    def self.openocd(worker_name, name, config)
       msg = ""
       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)
+          puts "Device firmware already cached at #{path}. Using cached version. To download a new copy of the device firmware, delete the file at #{path}.\n"
         else
+          puts "Downloading device firmware...\n"
           firmware_data = Apiotics::Portal.download_firmware(worker_name)
           file = File.new(path, 'w')
           file.write firmware_data["file"].force_encoding(Encoding::UTF_8)
@@ -114,7 +115,7 @@ module Apiotics
           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"])
+        msg = self.openocd_install_firmware(config["openocd_config_file_name"], path, config["openocd_start_address"])
       else
         k = Apiotics.configuration.targets.keys
         puts "Worker could not be found.  The workers associated with your Hive are: #{k.join(',')}"
@@ -122,5 +123,222 @@ module Apiotics
       return msg
     end
     
+    def self.check_mac_uniflash_install
+      status = false
+      puts "Checking for Uniflash installation...\n"
+      path = "/Applications/ti/uniflash_4.3.0/dslite.sh"
+      if File.exist?(path)
+        puts "Uniflash installation found.\n"
+        status = true
+      else
+        puts "No Uniflash installation found.\n"
+      end
+      return status
+    end
+    
+    def self.check_linux_uniflash_install #need a Linux installation to check where UniFlash installs itself
+      status = false
+      puts "Checking for Uniflash installation...\n"
+      path = "#{Dir.home}/ti/uniflash_4.3.0/dslite.sh"
+      if File.exist?(path)
+        puts "Uniflash installation found.\n"
+        status = true
+      else
+        puts "No Uniflash installation found.\n"
+      end
+      return status
+    end
+    
+    def self.check_uniflash_install
+      status = false
+      if Hardware.mac == true
+        if Hardware.check_mac_uniflash_install == true
+          status = "/Applications/ti/uniflash_4.3.0/dslite.sh"
+        end
+      elsif Hardware.linux == true
+        if Hardware.check_linux_uniflash_install == true
+          status = "#{Dir.home}/ti/uniflash_4.3.0/dslite.sh"
+        end
+      else
+        puts "Your computer is not running a supported OS.  Please use either Mac OS or Linux to install your firmware.\n"
+      end
+      return status
+    end
+    
+    def self.import_uniflash_image(uniflash_path, path, config)
+      project_path = "#{Dir.home}/.SLImageCreator/projects/#{config['firmware_file_name'].split(".")[0]}"
+      if Dir.exist?(project_path)
+        FileUtils.remove_dir(project_path)
+      end
+      string = "#{uniflash_path} --mode #{config["openocd_config_file_name"]} project import --file #{path}"
+      puts "Creating uniflash project... \n"
+      msg = system(string)
+    end
+    
+    def self.find_uniflash_mac_address(uniflash_path, config)
+      mac_addr = nil
+      string = "#{uniflash_path} --mode #{config["openocd_config_file_name"]} device info"
+      puts "Finding device MAC address... \n"
+      msg = `#{string}`
+      mac_addr_start = msg.rindex("MAC          : ")
+      if mac_addr_start != nil
+        mac_addr_start = mac_addr_start + 15
+        mac_addr_end = msg.rindex("PROG MAC") - 1
+        mac_addr = msg[mac_addr_start..mac_addr_end].chomp
+      else
+        puts "Could not read MAC address.  Please press the reset button on your board and try running rake firmware:install again.\n"
+      end
+      return mac_addr
+    end
+    
+    def self.edit_json_config_mac_address(mac_address, config)
+      status = false
+      puts "Editing device configuration to assign device MAC address..."
+      path = "#{Dir.home}/.SLImageCreator/projects/#{config['firmware_file_name'].split(".")[0]}/#{config['firmware_file_name'].split(".")[0]}.json"
+      if File.exist?(path)
+        puts "json configuration file found...\n"
+        file = File.read(path)
+        puts "updating MAC address...\n"
+        json_config = JSON.parse(file)
+        json_config["header"]["DEV_MAC_ADDR"] = mac_address
+        json_config["systemFiles"]["CONFIG_TYPE_MAC"]["MAC_ADDR"] = mac_address
+        puts "writing updated json configuration file...\n"
+        File.write(path, json_config.to_json)
+        status = true
+      else
+        puts "Error: json configuration file could not be found at #{path}\n"
+      end
+      return status
+    end
+    
+    def self.create_uniflash_image(uniflash_path, config)
+      puts "Creating uniflash firmware image...\n"
+      string = "#{uniflash_path} --mode #{config["openocd_config_file_name"]} project create_image --name #{config['firmware_file_name'].split(".")[0]} --sli_file #{config['firmware_file_name'].split(".")[0]}.sli"
+      msg = system(string)
+    end
+    
+    def self.brand_uniflash_image(uniflash_path, config)
+      puts "Adding Hive and Worker Type details to the firmware image...\n"
+      details_hash = {
+        "hive_public_key" => config["hive_public_key"],
+        "hive_private_key" => config["hive_private_key"],
+        "worker_type" => config["worker_type"]
+      }
+      path = Rails.root.join('lib', 'uniflash', 'downloads', 'branding.json')
+      File.write(path, details_hash.to_json)
+      target_path = "branding.json"
+      string = "#{uniflash_path} --mode #{config["openocd_config_file_name"]} project add_file --name #{config["firmware_file_name"].split(".")[0]} --file #{path} --fs_path #{target_path} --overwrite --flags publicread"
+      msg = system(string)
+      File.delete(path)
+      wifi_path = Rails.root.join('lib', 'uniflash', 'downloads', 'wifi_settings')
+      if File.exist?(wifi_path)
+        Hardware.add_wifi_details(uniflash_path, config, wifi_path)
+      end
+    end
+    
+    def self.add_wifi_details(uniflash_path, config, wifi_path)
+      pwd = ApioticsSetting.find_by(key: "wifi_key").value
+
+      encrypted = File.read(wifi_path)
+
+      decrypted = encrypted.apiotics_decrypt(pwd)
+      
+      target_path = "wifi_settings.json"
+      path = Rails.root.join('lib', 'uniflash', 'downloads', 'wifi_settings.json')
+      File.write(path, decrypted)
+      string = "#{uniflash_path} --mode #{config["openocd_config_file_name"]} project add_file --name #{config["firmware_file_name"].split(".")[0]} --file #{path} --fs_path #{target_path} --overwrite --flags publicread"
+      msg = system(string)
+      File.delete(path)
+    end
+    
+    def self.write_uniflash_image(uniflash_path, config)
+      puts "Writing uniflash firmware image...\n"
+      string = "#{uniflash_path} --mode #{config["openocd_config_file_name"]} image program --file #{config['firmware_file_name'].split(".")[0]}.sli"
+      msg = system(string)
+    end
+    
+    def self.uniflash(worker_name, name, config)
+      uniflash_path = Hardware.check_uniflash_install
+      if uniflash_path != false 
+        download_directory = Rails.root.join('lib', 'uniflash')
+        Dir.mkdir download_directory unless Dir.exist?(download_directory)
+        download_directory = Rails.root.join('lib', 'uniflash', 'downloads')
+        Dir.mkdir download_directory unless Dir.exist?(download_directory)
+        Dir.chdir download_directory
+        unless config["openocd_config_file_name"] == nil || config["openocd_config_file_name"] == ""
+          path = Rails.root.join('lib', 'uniflash', 'downloads', config["firmware_file_name"])
+          if File.exist?(path)
+            puts "Device firmware already cached at #{path}. Using cached version. To download a new copy of the device firmware, delete the file at #{path}.\n"
+          else
+            puts "Downloading device firmware...\n"
+            firmware_data = Apiotics::Portal.download_firmware(worker_name)
+            file = File.new(path, 'w')
+            file.write firmware_data["file"].force_encoding(Encoding::UTF_8)
+            file.close
+          end
+          Hardware.import_uniflash_image(uniflash_path, path, config)
+          mac_address = Hardware.find_uniflash_mac_address(uniflash_path, config)
+          unless mac_address == nil
+            if Hardware.edit_json_config_mac_address(mac_address, config)
+              Hardware.brand_uniflash_image(uniflash_path, config)
+              Hardware.create_uniflash_image(uniflash_path, config)
+              Hardware.write_uniflash_image(uniflash_path, config)
+            end
+          end
+        else
+          k = Apiotics.configuration.targets.keys
+          puts "Worker could not be found.  The workers associated with your Hive are: #{k.join(',')}"
+        end
+      else
+        puts "Could not find Uniflash 4.3.0.  If you need to install it, please visit http://processors.wiki.ti.com/index.php/Category:CCS_UniFlash and install version 4.3.0.\n"
+      end
+    end
+    
+    def self.install(worker_name, name)
+      config = Apiotics::Portal.openocd_worker_config(worker_name)
+      config = JSON.parse(config)
+      if config["installer"] == "Open OCD 0.10"
+        Hardware.openocd(worker_name, name, config)
+      elsif config["installer"] == "Uniflash 4.3.0"
+        Hardware.uniflash(worker_name, name, config)
+      else
+        puts "Unknown installer for #{worker_name}.  Please check the installer settings for the #{worker_name} device on the Apiotics portal.\n"
+      end
+    end
+    
+    def self.wifi(ssid, password, security_mode)
+      args = {
+        "ssid" => ssid,
+        "password" => password,
+        "security_mode" => security_mode
+      }
+      args.keys.each do |key|
+        if args[key] == nil
+          args[key] = ""
+        end
+      end
+      
+      pwd = ApioticsSetting.find_by(key: "wifi_key")
+      if pwd == nil
+        s = ApioticsSetting.new
+        s.key = "wifi_key"
+        s.value = SecureRandom.hex
+        s.save
+        pwd = s.value
+      else
+        pwd = pwd.value
+      end
+
+      encrypted_wifi_config = args.to_json.apiotics_encrypt(pwd)
+      
+      download_directory = Rails.root.join('lib', 'uniflash')
+      Dir.mkdir download_directory unless Dir.exist?(download_directory)
+      download_directory = Rails.root.join('lib', 'uniflash', 'downloads')
+      Dir.mkdir download_directory unless Dir.exist?(download_directory)
+      Dir.chdir download_directory
+      path = Rails.root.join('lib', 'uniflash', 'downloads', 'wifi_settings')
+      File.write(path, encrypted_wifi_config)
+    end
+    
   end
 end

data/lib/apiotics/insert.rb

@@ -25,7 +25,7 @@ module Apiotics
         find_record
         @methods.each do |k,v|
           @type = @record.class.columns_hash[k].type
-          #change_value
+          change_value
           @record.send("#{k}=".to_sym, v)
           unless Apiotics.configuration.reduced_metadata == true
             @record.send(("#{k}_action=").to_sym, @action)

data/lib/apiotics/portal.rb

@@ -62,6 +62,11 @@ module Apiotics
     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)
+      if Apiotics.configuration.server_type == nil
+        Apiotics.configuration.server_type = hash["server_version"]
+        Apiotics.configuration.aws_endpoint = hash["aws_endpoint"] 
+      end
+      hash
     end
     
     def self.parse_all_interfaces
@@ -264,13 +269,41 @@ module Apiotics
       if gem_setting == nil
         gem_setting = ApioticsSetting.new
         gem_setting.key = "gem_id"
-        gem_setting.value = hash["guid"]
+        gem_setting.value = hash["public_hash"]
         gem_setting.save
       else
-        gem_setting.value = hash["guid"]
+        gem_setting.value = hash["public_hash"]
         gem_setting.save
       end
-      hash["guid"]
+      s = ApioticsSetting.find_by(key: "private_gem_hash")
+      if s == nil
+        s = ApioticsSetting.new
+        s.key = "private_gem_hash"
+        s.value = hash["private_hash"]
+        s.save
+      end
+      s = ApioticsSetting.find_by(key: "public_key")
+      if s == nil
+        s = ApioticsSetting.new
+        s.key = "public_key"
+        s.value = hash["public"]
+        s.save
+      end
+      s = ApioticsSetting.find_by(key: "private_key")
+      if s == nil
+        s = ApioticsSetting.new
+        s.key = "private_key"
+        s.value = hash["private"]
+        s.save
+      end
+      s = ApioticsSetting.find_by(key: "cert")
+      if s == nil
+        s = ApioticsSetting.new
+        s.key = "cert"
+        s.value = hash["cert"]
+        s.save
+      end
+      hash["public_hash"]
     end
     
   end

data/lib/apiotics/server.rb

@@ -6,6 +6,7 @@ require "socket"
 require 'openssl'
 require 'json'
 require "redis"
+require 'aws_iot_device'
 
 module Apiotics
   class Server
@@ -16,93 +17,174 @@ module Apiotics
             $redis = ::Redis.new
           end
         end
+        @localport = Apiotics.configuration.local_port
+        @error_msg = nil
         Thread.abort_on_exception = true
         hive_public_key = ApioticsSetting.find_by(key: "hive_public_key")
         if hive_public_key == nil || hive_public_key.value != Apiotics.configuration.public_key
           Server.clear_db_settings
         end
-        @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"]
+        if Apiotics::Server.server_type == "aws"
+          port = Apiotics.configuration.mqtt_port
+          key = Apiotics::Server.key
+          cert = Apiotics::Server.cert
+          ca_cert = Apiotics::Server.ca_cert
+          key_file = Tempfile.new
+          cert_file = Tempfile.new
+          ca_cert_file = Tempfile.new
+          key_file.write(key)
+          key_file.rewind
+          cert_file.write(cert)
+          cert_file.rewind
+          ca_cert_file.write(ca_cert)
+          ca_cert_file.rewind
+          aws_endpoint = Apiotics::Server.aws_endpoint
+          gem_id = Apiotics::Server.gem_id
+          Server.sync_devices(nil)
+          
+          @server = AwsIotDevice::MqttShadowClient::MqttManager.new
+          @server.config_endpoint(aws_endpoint, port)
+          @server.config_ssl_context(ca_cert_file.path, key_file.path, cert_file.path)
+          #@server.persistent = true
+          @server.connect(aws_endpoint, port, true, true, false)
+
+          @server.on_message do |packet|
+            msg = packet.payload
+            puts "Message received: " + msg
+            Server.parse_message(msg)
           end
+          
+          PahoMqtt.logger = "/Users/mackie/.apiotics/paho.log"
+          
+          @server.subscribe("topic/#{Apiotics.configuration.public_key}/setcomplete", 1)
+          @server.subscribe("topic/#{Apiotics.configuration.public_key}/setrequestack", 1)
+          @server.subscribe("topic/#{Apiotics.configuration.public_key}/getack", 1)
+          
+          Server.ping(@server)
+          
         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
+          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
-            @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
+            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
-          @server = OpenSSL::SSL::SSLSocket.new socket, context
-          @server.sync_close = true
-          @server.connect
-          if Apiotics.configuration.verify_peer == true
-            ca_tempfile.close(true)
+          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
-        else
-          @server = TCPSocket.open(rgs, rgs_port)
+          Server.sync_devices(nil)
+        
+          listen_remote
+          @heartbeat_state = Hash.new
+          heartbeat = {
+            "action" => "heartbeat",
+            "hive_id" => Apiotics.configuration.public_key,
+            "instance_id" => "0000000000000000000000000000000000000000000000000000000000000000",
+            "driver" => "Core::Heartbeat",
+            "interface" => nil
+          }
+          send_heartbeat(heartbeat)
         end
-        Server.sync_devices(nil)
-        @localport = Apiotics.configuration.local_port
-        listen_remote
-        @heartbeat_state = Hash.new
-        heartbeat = {
-          "action" => "heartbeat",
-          "hive_id" => Apiotics.configuration.public_key,
-          "instance_id" => "0000000000000000000000000000000000000000000000000000000000000000",
-          "driver" => "Core::Heartbeat",
-          "interface" => nil
-        }
-        send_heartbeat(heartbeat)
+        puts "Starting local server..."
         listen_local
       rescue => e
-        if @server != nil
-          @server.close
-        end
+        Server.close
         puts e.message
         puts e.backtrace.inspect
         raise e
       end
     end
+    
+    def self.ping(server)
+      Thread.abort_on_exception = true
+      Thread.new do
+        msg = {"p" => "p"}
+        loop do
+          server.publish("topic/ping", msg.to_json, false, 1)
+          sleep 30
+        end
+      end
+    end
 
     def send(msg)
-      puts "Message sent: #{msg}"
-      @server.puts( msg )
+      # need to check for which server.
+      if Apiotics.configuration.server_type == "aws"
+        msg = JSON.parse(msg)
+        if msg["action"] == "get"
+          msg["driver"] = msg["driver"].split("::")[1]
+          @server.publish("topic/#{Apiotics.configuration.public_key}/get", msg.to_json, false, 1)
+        else
+          #send_msg = {
+          #  "state" => {
+          #    "desired" => {
+          #      msg["driver"].split("::")[1] => msg["interface"]
+          #    }
+          #  }
+          #}
+          #puts "Message sent: #{send_msg.to_json} to #{"$aws/things/#{msg["instance_id"]}/shadow/update"}"
+          #@server.publish("$aws/things/#{msg["instance_id"]}/shadow/update", send_msg.to_json, false, 1)
+          puts "Message sent: #{msg.to_json} to #{"topic/#{Apiotics.configuration.public_key}/setrequest"}"
+          @server.publish("topic/#{Apiotics.configuration.public_key}/setrequest", msg.to_json, false, 1)
+        end
+      else  
+        puts "Message sent: #{msg}"
+        @server.puts( msg )
+      end
     end
     
-    def close
-      @server.close
+    def self.close
+      #need to check for which server.
+      if Apiotics.configuration.server_type == "aws"
+        if @server != nil
+          @server.disconnect
+        end
+      else
+        if @server != nil
+          @server.close
+        end
+      end
     end
     
     def listen_remote
@@ -112,19 +194,7 @@ module Apiotics
           loop do
         	  msg = @server.gets
         	  puts "Message received: " + msg
-            msg_hash = Apiotics::Parse.message(msg)
-            #puts "Driver: " + msg_hash["driver"]
-            unless msg_hash["driver"] == "Core::Heartbeat" || msg_hash["action"] == "sync" || msg_hash["error"] != nil
-              r = Apiotics::Insert.new(msg_hash)
-              if r.valid == true
-                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
+            msg_hash = Server.parse_message(msg)
             if msg_hash["driver"] == "Core::Heartbeat"
               monitor_heartbeat(msg_hash)
             elsif msg_hash["action"] == "sync"
@@ -151,10 +221,28 @@ module Apiotics
       end
     end
     
+    def self.parse_message(msg)
+      msg_hash = Apiotics::Parse.message(msg)
+      #puts "Driver: " + msg_hash["driver"]
+      unless msg_hash["driver"] == "Core::Heartbeat" || msg_hash["action"] == "sync" || msg_hash["error"] != nil
+        r = Apiotics::Insert.new(msg_hash)
+        if r.valid == true
+          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 
+      msg_hash
+    end
+    
     def listen_local
       if Apiotics.configuration.redis_comms_connection == false
         begin
           @local_server = TCPServer.open(@localport)
+          puts "Local server started..."
           loop do
             Thread.abort_on_exception = true
           	Thread.fork(@local_server.accept) do |client| 
@@ -163,7 +251,7 @@ module Apiotics
           		  string = '{"error":"' + error_msg + '"}'
           		  client.puts(string)
           		end
-          		#puts s
+          		#puts "Sending message to Server.send #{s}"
           		self.send(s)
           	end
           end
@@ -188,12 +276,7 @@ module Apiotics
     
     def send_heartbeat(heartbeat)
       if Apiotics.configuration.handshake == true
-        gem_id = ApioticsSetting.find_by(key: "gem_id")
-        if gem_id == nil
-          gem_id = Apiotics::Portal.register_client
-        else
-          gem_id = gem_id.value
-        end
+        gem_id = Server.gem_id
         connect_msg = {
           "action" => "connect",
           "hive_id" => Apiotics.configuration.public_key,
@@ -284,28 +367,34 @@ module Apiotics
       return hash
     end
     
+    def self.gem_id
+      gem_id = ApioticsSetting.find_by(key: "gem_id")
+      if gem_id == nil
+       gem_id = Apiotics::Portal.register_client
+      else
+       gem_id = gem_id.value
+      end
+      gem_id
+    end
+    
     def self.key
-      key = ApioticsSetting.find_by(key: "key")
+      key = ApioticsSetting.find_by(key: "private_key")
       if key == nil
-        key = Server.generate_key
+        Apiotics::Portal.register_client
+        key = ApioticsSetting.find_by(key: "private_key")
+        key = key.value
       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
+        Apiotics::Portal.register_client
+        cert = ApioticsSetting.find_by(key: "cert")
+        cert = cert.value
       else
         cert = cert.value
       end
@@ -313,29 +402,6 @@ module Apiotics
       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
@@ -369,6 +435,42 @@ module Apiotics
       hive_public_key.save
     end
     
+    def self.server_type
+      s = ApioticsSetting.find_by(key: "server_type")
+      if s == nil
+        if Apiotics.configuration.server_type == nil
+          hash = Apiotics::Portal.retrieve_configuration
+          Apiotics.configuration.server_type == hash["server_version"]
+          server_type = hash["server_version"]
+        else
+          server_type = Apiotics.configuration.server_type
+        end
+        s = ApioticsSetting.new
+        s.key = "server_type"
+        s.value = server_type
+        s.save
+      end
+      s.value
+    end
+    
+    def self.aws_endpoint
+      s = ApioticsSetting.find_by(key: "aws_endpoint")
+      if s == nil
+        if Apiotics.configuration.aws_endpoint == nil
+          hash = Apiotics::Portal.retrieve_configuration
+          Apiotics.configuration.server_type == hash["aws_endpoint"]
+          aws_endpoint = hash["aws_endpoint"]
+        else
+          aws_endpoint = Apiotics.configuration.aws_endpoint
+        end
+        s = ApioticsSetting.new
+        s.key = "aws_endpoint"
+        s.value = aws_endpoint
+        s.save
+      end
+      s.value
+    end
+    
     def do_at_exit
     end
     

data/lib/apiotics/version.rb

@@ -1,3 +1,3 @@
 module Apiotics
-  VERSION = '0.1.141'
+  VERSION = '0.2.0'
 end

data/lib/generators/apiotics/controller/controller_generator.rb

@@ -7,7 +7,7 @@ module Apiotics
       @models = Apiotics.configuration.targets[module_name.to_s]
       template "apiotics_scaffold.rb.erb", "app/controllers/#{module_file_name}/#{module_file_name.pluralize}_controller.rb"
       generate "apiotics:view", "#{parent}"
-      route "scope module: :#{module_file_name} do \n\t\tresources :#{module_file_name}s\n\tend\n"
+      route "scope module: :#{module_file_name} do \n\t\tresources :#{module_file_name}s\n\tend"
       generate "simple_form:install"
     end
     

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

@@ -21,6 +21,7 @@ module Apiotics
       copy_file "dev_comm_server.rake", "lib/tasks/dev_comm_server.rake"
       copy_file "publish_script.rake", "lib/tasks/publish_script.rake"
       copy_file "install_firmware.rake", "lib/tasks/install_firmware.rake"
+      copy_file "set_wifi.rake", "lib/tasks/set_wifi.rake"
       FileUtils.chmod 0775, "lib/scripts/server_control.rb"
       FileUtils.chmod 0775, "lib/scripts/heroku_server_control.rb"
     end

data/lib/generators/apiotics/script/templates/install_firmware.rake

@@ -2,9 +2,9 @@ namespace :firmware do
   desc "Install firmware on devices.  Use rake firmware:install {worker_name} to install firmware on a device.  Use rake firmware:install {worker_name} {instance_name} to install firmware and set a name for the device."
   task :install, [:worker, :name] => [:environment] do |task, args|
     if args[:name] == nil
-      Apiotics::Hardware.openocd(args[:worker], nil)
+      Apiotics::Hardware.install(args[:worker], nil)
     else
-      Apiotics::Hardware.openocd(args[:worker], args[:name])
+      Apiotics::Hardware.install(args[:worker], args[:name])
     end
   end
 end

data/lib/generators/apiotics/script/templates/set_wifi.rake

@@ -0,0 +1,13 @@
+namespace :firmware do
+  desc "Set Wifi details for a device (if applicable).  Use rake firmware:wifi[ssid, password, security_mode] to set the wifi details for a device."
+  task :wifi, [:ssid, :password, :security_mode] => [:environment] do |task, args|
+    security_modes = ["WEP", "WPA", "WPA2"]
+    if args[:security_mode] != nil
+      unless security_modes.include?(args[:security_mode])
+        puts "#{args[:security_mode]} is not a supported WiFi security mode.  The supported security modes are: #{security_modes.to_s}"
+      else
+        Apiotics::Hardware.wifi(args[:ssid], args[:password], args[:security_mode])
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: apiotics
 version: !ruby/object:Gem::Version
-  version: 0.1.141
+  version: 0.2.0
 platform: ruby
 authors:
 - MicroArx Corporation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2018-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: apiotics-aws-iot-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -163,6 +177,7 @@ files:
 - lib/apiotics/client.rb
 - lib/apiotics/configuration.rb
 - lib/apiotics/connection_error.rb
+- lib/apiotics/encrypt_decrypt.rb
 - lib/apiotics/extract.rb
 - lib/apiotics/hardware.rb
 - lib/apiotics/insert.rb
@@ -220,6 +235,7 @@ files:
 - lib/generators/apiotics/script/templates/script.rb.erb
 - lib/generators/apiotics/script/templates/server.rb
 - lib/generators/apiotics/script/templates/server_control.rb
+- lib/generators/apiotics/script/templates/set_wifi.rake
 - lib/generators/apiotics/script/templates/test_comm_server.rake
 - lib/generators/apiotics/script/templates/test_server.rb
 - lib/generators/apiotics/script/templates/test_server_control.rb
@@ -251,7 +267,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: IoT For Everybody.