SensorStream 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b39b1d786a844a90ad09029f664b11ba6ac86bf
-  data.tar.gz: 1923ab463642ce72360f5d5fcdef91f049877042
+  metadata.gz: 8c0fac5d01abfb17186ab0f582c555ed09b49ac2
+  data.tar.gz: b3f6a855df09dbaa26dfb80af910bdba4a809524
 SHA512:
-  metadata.gz: dc0b813e4d2a64cc25450782471f6d6ec72ed087f048eeececde97f568844c1873369b7e25b530111d9b10980583bd1cfbc8bc387638bac2ef490b3c7845ad7c
-  data.tar.gz: 4df0e7348503bf383b93c22230a69c67ad7ee134b7a403a651788679e9cf560f7b525d538c25397072c1d94f359d97fe73b12c0c31c9702798a8d6cae20ee6a2
+  metadata.gz: af878ffa2bf56e349b50340ab7323fbafdfc748ddb661efa5898610b5eee70ee7b864b10b92c69bbbbaa1265b65c6c7db96700d6b9144107f221de6625f2c675
+  data.tar.gz: 7af61bbeb3fe8e1a1d1fe37885a6b444503d407e23390673512125e90209a954cbbf960daa380bd684fb14721ea0a6f44ac0dd0362f0bf0fb452e38a30d1f3cc

data/lib/SensorStream.rb

@@ -7,15 +7,18 @@ require 'pp'
 require 'base64'
 require 'open3'
 require 'date'
+#require 'Zlib'
 
 module SensorStream
   attr_accessor :host_name, :port_number
   
+  # Allows the SensorStream server to be overridden
   def self.set_default_server
-    @host_name = "dodeca.coas.oregonstate.edu"
+    @host_name = "sensorstream.cloudapp.net"
     @port_number = 80
   end
   
+  # Internally used to wrap HTTP puts with the requires headers
   def self.make_http_post(request = "", body_dict = {}, header_dict = {}, timeout = 600, debug = false)
     # Ensure that the hostname and port are set
     self.set_default_server unless !@host_name.nil?
@@ -23,35 +26,42 @@ module SensorStream
     # Make sure that, at a minimum, the content type is set in the header
     header_dict["Content-Type"] = "application/json";
     
-    puts header_dict unless !debug
-    
     uri  = URI.parse("http://" + @host_name + request);
-    puts "POST to #{uri.to_s}" unless !debug
+    if (debug)
+      puts "POST to #{uri.to_s}"
+      puts "Header: #{header_dict}"
+      puts "Body: #{JSON.generate(body_dict)}"
+    end
 
     http = Net::HTTP.new(@host_name, @port_number);
     http.read_timeout = timeout; # 10 minute default timeout
     http.post(uri.request_uri, JSON.generate(body_dict), header_dict);
+    # This is very important:  we're making use of the implied return of ruby, here!!!
   end
   
+  # Internally used to wrap HTTP gets with the required headers
   def self.make_http_get(request = "", header_dict = {}, timeout = 600, debug = false)
     # Ensure that the hostname and port are set
     self.set_default_server unless !@host_name.nil?
 
-    puts header_dict unless !debug
   
     uri  = URI.parse("http://" + @host_name + request);
-    puts "GET from #{uri.to_s}" unless !debug
+    if (debug)
+      puts "GET from #{uri.to_s}"
+      puts "Header: #{header_dict.to_s}"
+    end
 
     http = Net::HTTP.new(@host_name, @port_number);
     http.read_timeout = 600; # 10 minute timeout
     http.get(uri.request_uri, header_dict);
+    # This is very important:  we're making use of the implied return of ruby, here!!!
   end
   
   # create a new device on the server
   def self.create_device(user_name, device_name, description)
-    dict = {"UserName"    => user_name,
-            "DeviceName"  => device_name,
-            "Description" => description}
+    dict = {"username"    => user_name,
+            "devicename"  => device_name,
+            "description" => description}
     
     resp = make_http_post("/device.ashx?create=", dict)
     
@@ -62,6 +72,7 @@ module SensorStream
     end
   end
   
+  # Delete a device with a given key from the server
   def self.delete_device_with_key(device_key)
     puts "Deleting device #{device_key}"
     resp = make_http_post("/device.ashx?delete=device", {}, { "key" => device_key })
@@ -74,10 +85,12 @@ module SensorStream
     end  
   end
   
+  # Deletes a device from the server given a ruby object with a key
   def self.delete_device(device)
     delete_device_with_key(device.key)
   end
   
+  # Delete a stream from a device given a streamID and device key
   def self.delete_stream_with_key(streamID, device_key)
     puts "Deleting Stream #{streamID}"
     resp = make_http_post("/stream.ashx?delete=#{streamID}", {}, { "key" => device_key })
@@ -90,6 +103,7 @@ module SensorStream
     end
   end
   
+  # Reads a list of devices from the server
   def self.get_devices()
     resp = make_http_get("/device.ashx?getdevices=");
     
@@ -97,22 +111,38 @@ module SensorStream
       return nil;
     else
       devices = [];
-      JSON.parse(resp.body)["Devices"].each { |device|
-        devices << SensorStream::Device.new(device["UserName"],
-                                            device["DeviceName"],
-                                            device["Description"])
-        devices.last.get_streams
+      JSON.parse(resp.body).each { |device|
+        devices << SensorStream::Device.new(device["username"],
+                                            device["devicename"],
+                                            device["description"])
+        #devices.last.get_streams
       }
       return devices;
     end
   end
   
+  # Retreives a device given a device name
+  def self.get_device_by_name(name)
+    devices = SensorStream.get_devices
+    device = nil
+    devices.each { |test_device|
+      if (test_device.device_name == name)
+        return test_device
+      end
+    }
+    
+    return nil
+  end
+  
+  # Implementation of the device class
   class Device
     # Each of the qualities of a device are immutable.
     # The sensor stream API does not support changing device attributes.
     attr_reader :user_name, :device_name, :description
+    # It is possible to change the streams and assign a key later, however.
     attr_accessor :streams, :key
     
+    # Initialize a new SensorStream device object
     def initialize(newUserName, newDeviceName, newDescription, newStreams = [], newKey = "")
       @key         = newKey
       @device_name = newDeviceName
@@ -121,14 +151,26 @@ module SensorStream
       @streams     = newStreams
     end
 
+    # Create a useful (to a human) representation of the device for printing
     def to_s
       "Name: #{@device_name} \n\tUser: #{@user_name} \n\tDescription: #{@description} \n\tKey: #{@key}"
     end
 
-    def create_complex_stream(name, description, elements)
-      dict = {"Name"        => name,
-              "Description" => description,
-              "Streams"     => elements};
+    # Create a new stream on this device
+    def create_stream(name, description, elements)
+    
+      # Enforce lower-case values on all given element keys
+      tempElements = []
+      elements.each { |element|
+        new_hash = element.each_with_object({}) do |(k, v), h|
+          h[k.downcase] = v
+        end
+        tempElements << new_hash
+      }
+      
+      dict = {"name"        => name,
+              "description" => description,
+              "streams"     => tempElements};
       
       resp = SensorStream.make_http_post("/stream.ashx?create=", dict, { "key" => @key })
       
@@ -136,28 +178,14 @@ module SensorStream
         STDERR.puts "Error creating SensorStream device! (#{resp.code})\n#{resp.body}"
         return nil
       else
-        return ComplexStream.new(self, JSON.parse(resp.body)["StreamID"], name, description, elements)
-      end
-    end
-    
-    def create_stream(name, type, units, description)
-      dict = {"Name"       => name,
-              "Type"       => type,
-              "Units"      => units,
-              "Description" => description}
-      
-      resp = SensorStream.make_http_post("/stream.ashx?create=", dict, { "key" => @key })
-      
-      if (resp.code != "200")
-        STDERR.puts "Error creating SensorStream stream! (#{resp.code})\n#{resp.body}"
-      else
-        Stream.new(self, JSON.parse(resp.body)["StreamID"], name, type, units, description)
+        return Stream.new(self, JSON.parse(resp.body)["streamid"], name, description, tempElements)
       end
     end
     
-    def delete_stream_with_id(streamID)
-      puts "Deleting Stream #{streamID}"
-      resp = SensorStream.make_http_post("/stream.ashx?delete=#{streamID}", {}, { "key" => @key })
+    # Delete a stream from this device using a stream ID    
+    def delete_stream_with_id(streamid)
+      puts "Deleting Stream #{streamid}"
+      resp = SensorStream.make_http_post("/stream.ashx?delete=#{streamid}", {}, { "key" => @key })
     
       if (resp.code != "200")
         STDERR.puts "Error deleting stream #{streamID} (#{resp.code})\n{resp.body}"
@@ -167,37 +195,32 @@ module SensorStream
       end
     end
     
+    # Delete a stream from this device using a ruby object
     def delete_stream(stream)
-      delete_stream_with_id(stream.streamID)
+      delete_stream_with_id(stream.streamid)
     end
     
+    # Delete all the streams belonging to this device
     def delete_streams
       puts "Deleting all streams"
       resp = SensorStream.make_http_post("/device.ashx?delete=streams", {}, { "key" => @key }, 600, true)
     
       if (resp.code != "200")
-        STDERR.puts "Error deleting stream #{streamID} (#{resp.code})\n{resp.body}"
+        STDERR.puts "Error deleting stream #{streamid} (#{resp.code})\n{resp.body}"
         false
       else
         true
       end
     end
     
+    # Get a list of all the streams for this device
     def get_streams
       resp = SensorStream.make_http_get("/stream.ashx?getstreams=#{URI::encode(@device_name)}&user=#{URI::encode(@user_name)}")
       
       if (resp.code == "200")
         streams = []
-        JSON.parse(resp.body)["Streams"].each do |streamDict|
-          # Detect whether the stream we just got is complex
-          if(streamDict["Streams"].nil?)
-            streams << Stream.new(self,
-                                  streamDict["StreamID"], streamDict["Name"],
-                                  streamDict["Type"], streamDict["Units"],
-                                  streamDict["Description"])
-          else
-            streams << ComplexStream.new(self, streamDict["StreamID"], streamDict["Name"], streamDict["Description"], streamDict["Streams"])
-          end
+        JSON.parse(resp.body)["streams"].each do |streamDict|
+          streams << Stream.new(self, streamDict["streamid"], streamDict["name"], streamDict["description"], streamDict["streams"])
         end    
         return streams;
       else
@@ -205,151 +228,152 @@ module SensorStream
         return nil
       end
     end
+    
+    # Get a stream by name
+    def get_stream_by_name(name)
+      streams = self.get_streams
+      stream = nil
+      streams.each { |test_stream|
+        if (test_stream.name == name)
+          return test_stream
+        end
+      }
+      
+      return nil
+    end
   end
   
   # The simple stream class is the base class for complex streams
   class Stream
     # Each of the qualities of the stream are immutable.
     # The sensor stream API does not support changing stream attributes.
-    attr_reader :device, :streamID, :name, :type, :units, :description
+    attr_reader :device, :streamid, :name, :description, :elements
     
-    def initialize(newDevice, newStreamID, newName, newType, newUnits, newDescription)
-      @device        = newDevice
-      @streamID      = newStreamID
-      @name          = newName
-      @type          = newType
-      @units         = newUnits
-      @description   = newDescription
-      @deferedEvents = [];
-    end    
+    # Initalize the fields of the stream object    
+    def initialize(newDevice, newStreamid, newName, newDescription, newElements)
+      @device         = newDevice
+      @streamid       = newStreamid
+      @name           = newName
+      @elements       = newElements
+      @description    = newDescription
+      @deferredEvents = []
+    end
     
+    # Create a useful (to a human) representation of the device for printing
     def to_s
-      "Name: #{@name} \n\tStreamID: #{@streamID} \n\tType: #{@type} " +
-      "\n\tUnits: #{@units} \n\tDescription: #{@description}" +
-      "\n\tDevice: #{device.device_name}"
+      elementsString = "";
+      @elements.each do |element|
+        elementsString += "\n\t\t#{element["name"]}" +
+                          "\n\t\t\tTypes: #{element["type"]}" +
+                          "\n\t\t\tUnits: #{element["units"]}"
+      end
+      
+      "Name: #{@name} \n\tStreamID: #{@streamid} " + 
+                     "\n\tElements: #{elementsString} " + 
+                     "\n\tDescription: #{@description}" +
+                     "\n\tDevice: #{device.device_name}"
     end
 
-    def publish_event(value, time = nil)
-      dict = { "StreamID" => @streamID, "value" => value.to_s }
-      dict["Time"] = time.strftime("%FT%T.%N%:z") unless time.nil?
-
-      #puts dict
+    # Publish an event immediately.  If it doesn't succeed, add to the deferred queue.
+    def publish_event(values, time=nil)    
+      dict = {"streamid" => @streamid, "values" => values};
+      dict["time"] = time.strftime("%FT%T.%N%:z") unless time.nil?
+      attemptTime = Time.now
 
       resp = SensorStream.make_http_post("/data.ashx?create=", dict, { "key" => @device.key })
-
+      
       if (resp.code != "200")
-        STDERR.puts "Error publishing SensorStream event! (#{resp.code})\n#{resp.body}"
-        return nil
+        STDERR.puts "Error publishing SensorStream event! (#{resp.code})\n#{resp.body} -- deferring message"
+        publish_event_deferred(values, attemptTime)
+        return nil;
       else
-        DateTime.strptime(JSON.parse(resp.body)["Time"],"%FT%T.%N%:z")
+        DateTime.strptime(JSON.parse(resp.body)["time"],"%FT%T.%N%:z")
       end
     end
     
-    def publish_event_defered(value, time = nil)
+    # Add an event to the deferred message queue
+    def publish_event_deferred(values, time=nil)
       time ||= Time.now
-      @defered_events << { "StreamID" => @streamID,
-                           "value"    => value.to_s,
-                           "Time"     => time.strftime("%FT%T.%N%:z") }
+
+      if(@deferred_events.nil?)
+        @deferred_events = []
+      end
+
+      @deferred_events << { "streamid" => @streamid,
+                            "values"   => values,
+                            "time"     => time.strftime("%FT%T.%N%:z") }
     end
     
-    def publish_defered_events
-      # Ensure that there are defered messages to send
-      if(@deferedEvents.nil? || @deferedEvents.empty?)
-        @deferedEvents = [] unless !@deferedEvents.nil?
-        return
+    # Publish all the deferred events (if there are any)
+    def publish_deferred_events
+      # Ensure that there are deferred messages to send
+      if(@deferred_events.nil? || @deferred_events.empty?)
+         @deferred_events = [] unless !@deferred_events.nil?
+        puts "No events to publish" 
+        if (@deferred_events.nil?)
+          puts "Deferred events nil."
+        elsif (@deferred_events.empty?)
+          puts "Deferred events empty."
+        end
+        return 0
       end
 
-      resp = SensorStream.make_http_post("/data.ashx?create=", @defered_events, { "key" => @device.key })
+      resp = SensorStream.make_http_post("/data.ashx?create=", @deferred_events, { "key" => @device.key })
       
       # If the send failed, keep the messages
       if resp.code != "200"
-        puts "Unable to publish defered events, keeping events."
+        puts "Unable to publish deferred events, keeping events."
+        return 0
       else
-        count = @deferedEvents.count
-        @deferedEvents = []
+        count = @deferred_events.count
+        @deferred_events = []
         return count
       end
     end
 
+    # Download a list of events from the server from this stream
     def get_events(count = 1, start_time = nil, end_time = nil)
-      base = "/data.ashx?getdata=#{@streamID}"
+      base = "/data.ashx?getdata=#{@streamid}"
       base += "&start=#{start_time.strftime("%FT%T.%N%:z")}" unless start_time.nil?
       base += "&end=#{    end_time.strftime("%FT%T.%N%:z")}" unless end_time.nil?
       base += "&count=#{count}"
 
-      resp = SensorStream.make_http_get(base)
+      resp = SensorStream.make_http_get(base, {"Accept-Encoding" => "gzip"}, 600, true)
 
       if resp.code != "200"
-        puts "Unable to load events from stream"
+        STDERR.puts  "Unable to load events from stream: #{resp.body}"
         return nil
       end
 
+      if (resp["Content-Encoding"] == "gzip")
+        puts "Content was zipped, inflating"
+        content = Zlib::Inflate.inflate(resp.body)
+        puts resp.body
+      elsif
+        content = resp.body
+      end
+      
       # We're only interested in the values and their timestamps
       # but the server gives us the device information anyway
       # Return only the Data array from the dictionary
-      #puts resp.body
-      data = JSON.parse(resp.body)["Stream"]["Data"]
-      if data.class == Array
-        data.each { |event_dict|
-          #puts event_dict
-          # Replace the time string with Ruby time objects
-          event_dict["Time"] = DateTime.strptime(event_dict["Time"],"%FT%T.%N%:z")
-          #puts event_dict
-        }
-        return data
-      else
-        return [event_dict["Time"] = DateTime.strptime(event_dict["Time"],"%FT%T.%N%:z")];
-      end
-    end
-  end
-  
-  class ComplexStream < Stream
-    #attr_protected :type, :units
-    attr_reader :elements
-    def initialize(newDevice, newStreamID, newName, newDescription, newElements)
-      @device        = newDevice
-      @streamID      = newStreamID
-      @name          = newName
-      @elements      = newElements
-      @description   = newDescription
-      @deferedEvents = []
-    end
-    
-    def to_s
-      elementsString = "";
-      @elements.each do |element|
-        elementsString += "\n\t\t#{element["Name"]}" +
-                          "\n\t\t\tTypes: #{element["Type"]}" +
-                          "\n\t\t\tUnits: #{element["Units"]}"
-      end
-      
-      "Name: #{@name} \n\tStreamID: #{@streamID} " + 
-                     "\n\tElements: #{elementsString} " + 
-                     "\n\tDescription: #{@description}" +
-                     "\n\tDevice: #{device.device_name}"
-    end
-    
-    def publish_event(values, time=nil)
-      dict = {"StreamID" => @streamID, "Values" => values};    
-      dict["Time"] = time.strftime("%FT%T.%N%:z") unless time.nil?
-
-      #puts dict
+      streams = (JSON.parse(resp.body)["streams"])
+      data = nil;
+      streams.each { |stream|
+        if (stream["streamid"] == @streamid)
+          data = stream["data"]
+        end
+      }
 
-      resp = SensorStream.make_http_post("/data.ashx?create=", dict, { "key" => @device.key })
-        
-      if (resp.code != "200")
-        STDERR.puts "Error publishing SensorStream event! (#{resp.code})\n#{resp.body}"
-        return nil;
-      else
-        DateTime.strptime(JSON.parse(resp.body)["Time"],"%FT%T.%N%:z")
+      if (data.nil?)
+        STDERR.puts "Can't find data in get events for this stream"
+        return nil
       end
+
+      data.each { |event_dict|
+        # Replace the time string with Ruby time objects
+        event_dict["time"] = DateTime.strptime(event_dict["time"],"%FT%T.%N%:z")
+      }
+      return data
     end
-    
-    def publish_event_defered(values, time=nil)
-      time ||= Time.now
-      @defered_events << { "StreamID" => @streamID,
-                           "Values"   => values,
-                           "Time"     => time.strftime("%FT%T.%N%:z") }
-    end
-  end
+  end  
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: SensorStream
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - William Dillon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2014-05-15 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby implementation of the SensorStream API
 email: william@housedillon.com
@@ -37,7 +37,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: SensorStream API