SensorStream 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a760100012763401669a1d3327ac113c459933a
-  data.tar.gz: c3ce3a0be9db81c05ec19ca9e9b535c85bd7b3f1
+  metadata.gz: d5d46b32fc009e3df9406da27578c1c7dd9f3af9
+  data.tar.gz: f35a58d2343ab7ef44eae4cdf80fb331aaede55f
 SHA512:
-  metadata.gz: 31c9f95c74dae973392dc0c98c9cc88c9e5a14058259c2f505ed52f4b9d5467e9c64e2cdc0e801e9461f8cae00216ef409e2bd1e9366a507921ee202c1bf596e
-  data.tar.gz: 5ed0bead38494f05e3d1b4fa9e980d6ca69720bfb7966ffc5dfe79586ecfdb613aa4424cb5d62e8971d08735dcd80b6f64c0e375baff6290362f7e199991db7a
+  metadata.gz: b54d4c6c333f5fdd86014aba0e1ef063976b63b45ad7ae030cf7714c0f6ad71c1b108c7723ce7184061eeb9ebe369fc265d9fa10d878e0dc26334f69619f5a25
+  data.tar.gz: 5fe47c0e29f9e57cc320dc6278cfe7a0a3d2800b6b9707b32ef84a0fd26eb761d73ff7bc9e5cf4e84174bb29b2541f477fa57419856dbf7336a1abc12ef2b804

data/lib/SensorStream.rb

@@ -28,8 +28,8 @@ module SensorStream
 
   # Allows the SensorStream server to be overridden
   def self.set_default_server
-    @host_name = "sensorstream.coas.oregonstate.edu"
-    @port_number = 80
+    @host_name = "dodeca.coas.oregonstate.edu"
+    @port_number = 443
   end
   
   # Internally used to wrap HTTP puts with the requires headers
@@ -40,7 +40,7 @@ module SensorStream
     # Make sure that, at a minimum, the content type is set in the header
     header_dict["Content-Type"] = "application/json";
     
-    uri  = URI.parse("http://" + @host_name + request);
+    uri  = URI::HTTPS.new('https', nil, @host_name, @port_number, nil, request, nil, nil, nil);
     if (debug)
       puts "POST to #{uri.to_s}"
       puts "Header: #{header_dict}"
@@ -49,6 +49,7 @@ module SensorStream
 
     http = Net::HTTP.new(@host_name, @port_number);
     http.read_timeout = timeout; # 10 minute default timeout
+    http.use_ssl = true
     retval = http.post(uri.request_uri, JSON.generate(body_dict), header_dict);
 
     return retval
@@ -60,65 +61,20 @@ end
     self.set_default_server unless !@host_name.nil?
 
   
-    uri  = URI.parse("http://" + @host_name + request);
+    uri  = URI::HTTPS.new('https', nil, @host_name, @port_number, nil, request, nil, nil, nil);
     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.read_timeout = timeout; # 10 minute timeout
+    http.use_ssl = true
     retval = http.get(uri.request_uri, header_dict);
 
     return retval
   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}
-    
-    resp = make_http_post("/device.ashx?create=", dict)
-    
-    if (resp.code != "200")
-      STDERR.puts "Error creating SensorStream device! (#{resp.code})\n#{resp.body}"
-    else
-      SensorStream::Device.new(user_name, device_name, description, [], JSON.parse(resp.body)["guid"])
-    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 })
-    
-    if (resp.code != "200")
-      STDERR.puts "Error deleting SensorStream device! (#{resp.code})\n#{resp.body}"
-      return false;
-    else
-      return true;
-    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 })
-    
-    if (resp.code != "200")
-      STDERR.puts "Error deleting stream #{streamID} (#{resp.code})\n#{resp.body}"
-      false
-    else
-      true
-    end
-  end
-  
+
   # Reads a list of devices from the server
   def self.get_devices()
     resp = make_http_get("/device.ashx?getdevices=");
@@ -133,27 +89,58 @@ end
       end
 
       JSON.parse(resp.body).each { |device|
-      devices << SensorStream::Device.new(device["username"],
-                                          device["devicename"],
-                                          device["description"]) }
+      devices << SensorStream::Device.new(device["DeviceID"],
+                                          device["UserName"],
+                                          device["DeviceName"],
+                                          device["Description"]) }
       return devices;
     end
   end
   
   # Retreives a device given a device name
-  def self.get_device_by_name(name)
-    devices = SensorStream.get_devices
-    if devices.nil?
+  def self.get_devices_by_name(name)
+    resp = make_http_get("/api/GetDevices?Dev=" + name, {})
+
+    if (resp.code != "200")
+        puts "Unable to get a response from SensorStream: " + resp.code
         return nil
+    else
+        retDevices = []
+        JSON.parse(resp.body).each { |device|
+        retDevices << SensorStream::Device.new(device["DeviceID"],
+                                               device["UserName"],
+                                               device["DeviceName"],
+                                               device["Description"]) }
+        return retDevices
     end
 
-    device = nil
-    devices.each { |test_device|
-      if (test_device.device_name == name)
-        return test_device
+    return nil
+  end
+
+  def self.get_device_by_id(id, key = "")
+    if key.empty?
+        resp = make_http_get("/api/GetDevice/" + id, {})
+    else
+      resp = make_http_get("/api/GetDevice/" + id + "?key=" + key, {})
+    end
+
+    if (resp.code != "200")
+      puts "Unable to get a response from SensorStream: " + resp.code
+      return nil
+    else
+      json = JSON.parse(resp.body)
+      device = SensorStream::Device.new(id,
+                                        json["UserName"],
+                                        json["DeviceName"],
+                                        json["Description"])
+      if !key.empty?
+          device.key = key
       end
-    }
-    
+      
+      device.get_streams
+      return device
+    end
+
     return nil
   end
   
@@ -161,12 +148,13 @@ end
   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
+    attr_reader :id, :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 = "")
+    def initialize(newID, newUserName, newDeviceName, newDescription, newStreams = [], newKey = "")
+      @id          = newID
       @key         = newKey
       @device_name = newDeviceName
       @user_name   = newUserName
@@ -176,76 +164,27 @@ 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}"
+      string = "Name: #{@device_name} \n\tID: #{@id} \n\tUser: #{@user_name} \n\tDescription: #{@description} \n\tKey: #{@key}"
+      streams.each { |stream| string += stream.to_s }
+      return string
     end
 
-    # 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 })
-      
-      if (resp.code != "200")
-        STDERR.puts "Error creating SensorStream device! (#{resp.code})\n#{resp.body}"
-        return nil
-      else
-        return Stream.new(self, JSON.parse(resp.body)["streamid"], name, description, tempElements)
-      end
-    end
-    
-    # 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}"
-        false
-      else
-        true
-      end
-    end
-    
-    # Delete a stream from this device using a ruby object
-    def delete_stream(stream)
-      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}"
-        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 key.empty?
+        resp = SensorStream.make_http_get("/api/GetStreams/#{@id}", {})
+      else
+        resp = SensorStream.make_http_get("/api/GetStreams/#{@id}?key=#{@key}", {})
+      end
       
       if (resp.code == "200")
-        streams = []
-        JSON.parse(resp.body)["streams"].each do |streamDict|
-          streams << Stream.new(self, streamDict["streamid"], streamDict["name"], streamDict["description"], streamDict["streams"])
-        end    
-        return streams;
+        @streams = []
+        json = JSON.parse(resp.body)
+        puts json["Streams"].count.to_s + " streams found in device."
+        json["Streams"].each do |streamDict|
+          @streams << Stream.new(self, streamDict["StreamID"], streamDict["StreamName"], streamDict["Description"], streamDict["DataStreams"])
+        end
+        return @streams;
       else
         puts "Unable to get streams from server (#{resp.code})\n#{resp.body}"
         return nil
@@ -264,6 +203,35 @@ end
       
       return nil
     end
+    
+    def get_stream_by_id(id, key = "")
+      if key.empty?
+        resp = SensorStream.make_http_get("/api/GetStream/" + id, {})
+      else
+        resp = SensorStream.make_http_get("/api/GetStream/" + id + "?key=" + key, {})
+      end
+
+      if (resp.code != "200")
+        puts "Unable to get a response from SensorStream: " + resp.code
+        return nil
+      else
+        strms = []
+        json = JSON.parse(resp.body)
+        puts json["Streams"].count.to_s + " streams found in device."
+        json["Streams"].each do |streamDict|
+          strms << Stream.new(self, streamDict["StreamID"], streamDict["StreamName"], streamDict["Description"], streamDict["DataStreams"])
+      end
+      return strms[0];
+        if !key.empty?
+          device.key = key
+        end
+
+        device.get_streams
+        return device
+      end
+
+      return nil
+    end
   end
   
   # The simple stream class is the base class for complex streams
@@ -303,14 +271,14 @@ end
       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 })
-      
+      resp = SensorStream.make_http_post("/api/AddData", [dict], { "key" => @device.key })
+
       if (resp.code != "200")
         STDERR.puts "Error publishing SensorStream event! (#{resp.code})\n#{resp.body} -- deferring message"
         publish_event_deferred(values, attemptTime)
-        return nil;
+        return false
       else
-        DateTime.strptime(JSON.parse(resp.body)["time"],"%FT%T.%N%:z")
+        return true
       end
     end
     
@@ -341,7 +309,7 @@ end
         return 0
       end
 
-      resp = SensorStream.make_http_post("/data.ashx?create=", @deferred_events, { "key" => @device.key })
+      resp = SensorStream.make_http_post("/api/AddData", @deferred_events, { "key" => @device.key })
       
       # If the send failed, keep the messages
       if resp.code != "200"
@@ -356,18 +324,18 @@ 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 = "/api/GetData/#{@streamid}?"
+      base += "count=#{count}"
       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, {"Accept-Encoding" => "gzip"}, 600, true)
+      resp = SensorStream.make_http_get(base, {"Accept-Encoding" => "gzip"})
 
       if resp.code != "200"
         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)
@@ -376,14 +344,16 @@ end
         content = resp.body
       end
       
+      #puts content
+      
       # 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
-      streams = (JSON.parse(resp.body)["streams"])
+      streams = (JSON.parse(content)["Streams"])
       data = nil;
       streams.each { |stream|
-        if (stream["streamid"] == @streamid)
-          data = stream["data"]
+        if (stream["StreamID"] == @streamid)
+          data = stream["Data"]
         end
       }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: SensorStream
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - William Dillon
@@ -19,7 +19,7 @@ files:
 - lib/SensorStream.rb
 homepage: http://ramone.coas.oregonstate.edu
 licenses:
-- Proprietary
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []