SensorStream 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d6699293fcd7d91151220cc95fc2c3f9b0ffd801
+  data.tar.gz: 06d13baa1c9f613fb28e8e90b5f1edca12a5c5e0
+SHA512:
+  metadata.gz: deeb66a8e324f490ec269779d0c67e4672c77a9675b12a1b6c6a26d1a74e5cc439746230b2709b9f534b8d5d15f6079fa462f5c603a238e13820b8d9abbe6d2e
+  data.tar.gz: 91945130364b7a516eb353002a0b19497d7d385014734967a43282a9c71b4e27b1982fee09772627883dfd8c927435e02dd7a98f05a546d7ddd3b602b3471753

data/lib/SensorStream.rb

@@ -0,0 +1,507 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'net/http'
+require 'json'
+require 'pp'
+require 'base64'
+require 'open3'
+
+module SensorStream
+    @hostName = "dodeca.coas.oregonstate.edu";
+    @portNumber = 80;
+    
+    # get/set hostname
+    def self.hostName=(newHostName)
+        @hostName = name;
+    end
+
+    def self.hostName
+        return @hostName;
+    end
+
+    def self.portNumber
+        return @portNumber;
+    end
+
+    def self.portNumber=(newPortNum)
+        @portNumber = newPortNum;
+    end
+
+    # create a new device on the server
+    def self.createDevice(userName, deviceName, description)
+        dict = {"UserName"    => userName,
+                "DeviceName"  => deviceName,
+                "Description" => description};
+        
+        uri  = URI.parse("http://" + @hostName + "/device.ashx?create=");
+        http = Net::HTTP.new(@hostName, @portNumber);
+        http.read_timeout = 600; # 10 minute timeout
+        resp = http.post(uri.request_uri,
+                         JSON.generate(dict),
+                         {"Content-Type" => "application/json"});
+                         
+        if (resp.code != "200")
+            STDERR.puts "Error creating SensorStream device! (" + resp.code + ")\n" + resp.body;
+            return nil;
+        else
+            #Get the GUID from the response and make a device object
+            respDict = JSON.parse(resp.body);
+            return SensorStream::Device.new(deviceName, userName,
+                                            description, respDict["guid"]);
+        end
+    end
+
+    def self.deleteDevice(deviceGUID)
+        uri  = URI.parse("http://" + @hostName + "/device.ashx?delete=device");
+        http = Net::HTTP.new(@hostName, @portNumber);
+        http.read_timeout = 600;
+        resp = http.post(uri.request_uri, "",
+                         {"Content-Type" => "application/json", "key" => deviceGUID});
+                         
+        if (resp.code != "200")
+            STDERR.puts "Error deleting SensorStream device! (" + resp.code + ")\n" + resp.body;
+            return false;
+        else
+            return true;
+        end
+    end
+
+    def self.getDevices()
+        uri  = URI.parse("http://" + @hostName + "/device.ashx?getdevices=");
+        http = Net::HTTP.new(@hostName, @portNumber);
+        http.read_timeout = 600; # 10 minute timeout
+        resp = http.get(uri.request_uri);
+
+        if (resp.code != "200")
+            return nil;
+        else
+            deviceDict = JSON.parse(resp.body);
+            devices = [];
+            deviceDict["Devices"].each do |device|
+                devices << SensorStream::Device.new(device["DeviceName"],
+                                                    device["UserName"],
+                                                    device["Description"]);
+            end
+            return devices;
+        end
+    end
+
+    class Device
+        @guid = "";
+        @deviceName = "";
+        @userName = "";
+        @description = "";
+        
+        def initialize(newDN, newUN, newDSC, newGuid = "")
+            @guid = newGuid;
+            @deviceName = newDN;
+            @userName = newUN;
+            @description = newDSC;
+        end
+        
+        def guid(newGUID = @guid)
+            return @guid = newGUID;
+        end
+        
+        def guid=(newGUID = @guid)
+            self.guid(newGUID);
+        end
+
+        def deviceName(newDeviceName = @deviceName)
+            return @deviceName = newDeviceName;
+        end
+
+        def deviceName=(newDeviceName)
+            self.deviceName(newDeviceName);
+        end
+
+        def userName(newUserName = @userName)
+            return @userName = newUserName;
+        end
+
+        def userName=(newUserName)
+            self.userName(newUserName);
+        end
+
+        def description(newDescription = @description)
+            return @description = newDescription;
+        end
+
+        def description=(newDescription)
+            self.description(newDescription);
+        end
+
+        def createComplexStream(name, description, elements)
+            dict = {"Name"        => name,
+                    "Description" => description,
+                    "Streams"     => elements};
+            
+            uri  = URI.parse("http://" + SensorStream.hostName + "/stream.ashx?create=");
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            resp = http.post(uri.request_uri,
+                             JSON.generate(dict),
+                             {"Content-Type" => "application/json",
+                             "key" => @guid});
+                             
+            if (resp.code != "200")
+                STDERR.puts "Error creating SensorStream device! (" + resp.code + ")\n" + resp.body;
+                return "";
+            else
+                #Get the GUID from the response
+                respDict = JSON.parse(resp.body);
+                tempStream = ComplexStream.new(@guid, respDict["StreamID"],
+                                               elements, name, description);
+                return tempStream;
+            end
+        end
+        
+        def createSimpleStream(name, type, units, description)
+            dict = {"Name"        => name,
+                    "Description" => description,
+                    "Type"        => type,
+                    "Units"       => units};
+            
+            uri  = URI.parse("http://" + SensorStream.hostName + "/stream.ashx?create=");
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            resp = http.post(uri.request_uri,
+                             JSON.generate(dict),
+                             {"Content-Type" => "application/json",
+                             "key" => @guid});
+                             
+            if (resp.code != "200")
+                STDERR.puts "Error creating SensorStream stream! (" + resp.code + ")\n" + resp.body;
+                #puts "Request URI: ";
+                #puts uri;
+                #puts "Request JSON: " + JSON.generate(dict);
+                return nil;
+            else
+                #Get the GUID from the response, return an object for the stream
+                respDict = JSON.parse(resp.body);
+                tempStream = SimpleStream.new(@guid, respDict["StreamID"],
+                                              name, type, units, description);
+                return tempStream;
+            end
+        end
+        
+        def deleteStream(streamID)
+            uri  = URI.parse("http://" + SensorStream.hostName + "/stream.ashx?delete=" + streamID);
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            resp = http.post(uri.request_uri, "",
+                             {"Content-Type" => "application/json", "key" => @guid});
+                             
+            if (resp.code != "200")
+                STDERR.puts "Error deleting stream " + streamID + " (" + resp.code + ")\n" + resp.body;
+                return false;
+            else
+                return true;
+            end
+        end
+
+        def getStreams()
+            uri  = URI.parse("http://" + SensorStream.hostName +
+                             "/stream.ashx?getstreams=" + @deviceName +
+                             "&user=" + @userName);
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            resp = http.get(uri.request_uri);
+
+            if (resp.code != "200")
+                return nil;
+            else
+                ret = JSON.parse(resp.body);
+                streams = [];
+                ret["Streams"].each do |streamDict|
+                    # Detect whether the stream we just got is complex
+                    if(streamDict["Streams"].nil?)
+                        tempStream = SimpleStream.new(@guid,
+                                                      streamDict["StreamID"],
+                                                      streamDict["Name"],
+                                                      streamDict["Type"],
+                                                      streamDict["Units"],
+                                                      streamDict["Description"]);
+                        streams << tempStream;
+                    else
+                        tempStream = ComplexStream.new(@guid,
+                                                       streamDict["StreamID"],
+                                                       streamDict["Streams"],
+                                                       streamDict["Name"],
+                                                       streamDict["Description"]);
+                        streams << tempStream;
+                    end
+                end
+                
+                return streams;
+            end
+        end
+    end
+    
+    class SimpleStream
+        @guid = "";
+        @streamID = "";
+        @name = "";
+        @type = "";
+        @units = "";
+        @description = "";
+        
+        def initialize(newGuid = "",
+                       newStreamID = "",
+                       newName = "",
+                       newType = "",
+                       newUnits = "",
+                       newDescription = "")
+            @guid = newGuid;
+            @streamID = newStreamID;
+            @name = newName;
+            @type = newType;
+            @units = newUnits;
+            @description = newDescription;
+        end
+        
+        def guid(newGUID = @guid)
+            return @guid = newGUID;
+        end
+        
+        def guid=(newGUID = @guid)
+            self.guid(newGUID);
+        end
+        
+        def streamID(newStreamID = @streamID)
+            return @streamID = newStreamID;
+        end
+
+        def streamID=(newStreamID)
+            self.streamID(newStreamID);
+        end
+
+        def name(newName = @name)
+            return @name = newName;
+        end
+        
+        def name=(newName)
+            self.name(newName);
+        end
+        
+        def type(newType = @type)
+            return @type = newType;
+        end
+        
+        def type=(newType)
+            self.type(newType);
+        end
+        
+        def units(newUnits = @units)
+            return @units = newUnits;
+        end
+        
+        def units=(newUnits)
+            self.units(newUnits);
+        end
+        
+        def description(newDescription = @description)
+            return @description = newDescription;
+        end
+        
+        def description=(newDescription)
+            self.description(newDescription);
+        end
+        
+        def to_s
+            return  "Name: " + @name +
+                    "\n\tStreamID: " + @streamID +
+                    "\n\tType: " + @type +
+                    "\n\tUnits: " + @units +
+                    "\n\tDescription: " + @description;
+        end
+        
+        
+        def publishEvent(value, time=nil)
+            dict = {"StreamID" => @streamID, "Value" => value.to_s};
+            
+            # This is unlikely to work yet.
+            # Need to convert from ruby time representation to ISO8601 format
+            if(time != nil)
+                dict["Time"] = time.strftime("%FT%T%:z");
+            end
+            
+            uri  = URI.parse("http://" + SensorStream.hostName + "/data.ashx?create=");
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            resp = http.post(uri.request_uri,
+                             JSON.generate(dict),
+                             {"Content-Type" => "application/json", "key" => @guid});
+                             
+            if (resp.code != "200")
+                STDERR.puts "Error publishing SensorStream event! (" + resp.code + ")\n" + resp.body;
+                return "";
+            else
+                #Get the GUID from the response
+                respDict = JSON.parse(resp.body);
+                return respDict["Time"];
+            end
+        end
+
+        def streamID
+            return @streamID;
+        end
+    end
+    
+    class ComplexStream
+        @guid = "";
+        @streamID = "";
+        @elements = [];
+        @name = "";
+        @description = "";
+        @deferedMsgs = [];
+
+        def initialize(newGuid = "", newStreamID = "",
+                       newElements = [], newName = "",
+                       newDescription = "")
+            @guid = newGuid;
+            @streamID = newStreamID;
+            @elements = newElements;
+            @name = newName;
+            @description = newDescription;
+        end
+        
+        def guid(newGUID = @guid)
+            return @guid = newGUID;
+        end
+        
+        def guid=(newGUID = @guid)
+            self.guid(newGUID);
+        end
+        
+        def streamID(newStreamID = @streamID)
+            return @streamID = newStreamID;
+        end
+        
+        def streamID=(newStreamID)
+            self.streamID(newStreamID);
+        end
+        
+        def name(newName = @name)
+            return @name = newName;
+        end
+        
+        def name=(newName)
+            self.name(newName);
+        end
+        
+        def type(newType = @type)
+            return @type = newType;
+        end
+        
+        def type=(newType)
+            self.type(newType);
+        end
+        
+        def units(newUnits = @units)
+            return @units = newUnits;
+        end
+        
+        def units=(newUnits)
+            self.units(newUnits);
+        end
+        
+        def description(newDescription = @description)
+            return @description = newDescription;
+        end
+        
+        def description=(newDescription)
+            self.description(newDescription);
+        end
+
+        def to_s
+            elementsString = "";
+            @elements.each {|element|
+                elementsString += "\n\t\t" + element["Name"] +
+                                  "\n\t\t\tUnits: " + element["Type"] +
+                                  "\n\t\t\tUnits: " + element["Units"];
+            };
+            
+            return  "Name: " + @name +
+                    "\n\tStreamID: " + @streamID +
+                    "\n\tElements: " + elementsString +
+                    "\n\tDescription: " + @description;
+        end
+
+        def publishEvent(values, time=nil)
+            dict = {"StreamID" => @streamID, "Values" => values};
+            
+            # Need to convert from ruby time representation to ISO8601 format
+            if(time != nil)
+                dict["Time"] = time.strftime("%FT%T%:z");
+            end
+            
+            uri  = URI.parse("http://" + SensorStream.hostName + "/data.ashx?create=");
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            resp = http.post(uri.request_uri, JSON.generate(dict),
+                             {"Content-Type" => "application/json", "key" => @guid});
+                             
+            if (resp.code != "200")
+                STDERR.puts "Error publishing SensorStream event! (" + resp.code + ")\n" + resp.body;
+                puts JSON.generate(dict);
+                return "";
+            else
+                #Get the time from the response
+                respDict = JSON.parse(resp.body);
+                return respDict["Time"];
+            end
+        end
+        
+        def publishEventDefered(values, time=nil)
+            dict = {"StreamID" => @streamID, "Values" => values};
+            
+            # Need to convert from ruby time representation to ISO8601 format
+            if(time != nil)
+                dict["Time"] = time.strftime("%FT%T%:z");
+            end
+            
+            if(@deferedMsgs.nil?)
+                #puts "Defered messages array was nil, not supposed to happen.";
+                @deferedMsgs = [];
+            end
+            @deferedMsgs << dict;
+        end
+        
+        def flushDeferedMsgs()
+            if @deferedMsgs.nil?
+                return 0;
+            end
+            
+            if (@deferedMsgs.count == 0)
+                return 0;
+            end
+            
+            jsonString = JSON.generate(@deferedMsgs)
+            #puts "Created JSON string";
+            
+            uri  = URI.parse("http://" + SensorStream.hostName + "/data.ashx?create=");
+            http = Net::HTTP.new(SensorStream.hostName, SensorStream.portNumber);
+            http.read_timeout = 600; # 10 minute timeout
+            
+            #puts "Created http object";
+            resp = http.post(uri.request_uri, jsonString,
+                             {"Content-Type" => "application/json", "key" => @guid});
+ 
+            if (resp.code != "200")
+                STDERR.puts "Error publishing SensorStream event! (" + resp.code + ")\n" + resp.body;
+                #puts JSON.generate(@deferedMsgs);
+                return -1;
+            else
+                #Get the GUID from the response
+                respDict = JSON.parse(resp.body);
+                count = @deferedMsgs.count;
+                @deferedMsgs = [];
+                return count;
+            end
+
+        end
+    end
+    
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: SensorStream
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Dillon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby implementation of the SensorStream API
+email: william@housedillon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/SensorStream.rb
+homepage: http://ramone.coas.oregonstate.edu
+licenses:
+- Proprietary
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: SensorStream API
+test_files: []