haystack_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bbe8505587fa1e720665305767e15d16a78a11b
+  data.tar.gz: 8ddbb550be5df6a595b1dd3740f6405c3acf9685
+SHA512:
+  metadata.gz: 93f07240acd1a2a50c41b2a9e27789c1b8d1cff16e4a2825d9f4577e7b345cedbe7581fe8b5370dffacb4e5885b6a9f30f7e8d371ade56017788a117a6f3b6c2
+  data.tar.gz: bc73973de118ee8a52e9dab9efc59ba9486b048d6bba07d9656c277e19a9610dbaaad5527362f14008b1e9e49c7fcffd471604fc0e4d9923d693821d360c3236

data/lib/haystack_ruby/auth/conversation.rb

@@ -0,0 +1,184 @@
+require 'securerandom' #consider using openssl random
+require 'base64'
+require 'openssl'
+module HaystackRuby
+  module Auth
+    module Scram
+      class Conversation
+        attr_reader :auth_token, :nonce, :server_nonce, :server_salt
+
+        def initialize(user, url)
+          @user = user
+          @url = url
+          @nonce = SecureRandom.base64.tr('=','') #TODO check if problem to potentially strip =
+          @digest = OpenSSL::Digest::SHA256.new 
+          @handshake_token = Base64.strict_encode64(@user.username)
+        end
+
+        def authorize
+          res = send_first_message
+          parse_first_response(res)
+          res = send_second_message
+          parse_second_response(res)
+        end
+
+        def connection 
+          @connection ||= Faraday.new(:url => @url) do |faraday|
+            # faraday.response :logger                  # log requests to STDOUT
+            faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+            faraday.headers['Accept'] = 'application/json' #TODO enable more formats
+            faraday.headers['Content-Type'] = 'text/plain'
+          end
+        end
+
+        # first message sent by client to server
+        def send_first_message
+          res = connection.get('about') do |req|
+            req.headers['Authorization'] = "SCRAM handshakeToken=#{@handshake_token},data=#{Base64.urlsafe_encode64(first_message).tr('=','')}"
+          end
+          res
+          
+        end
+
+        # pull server data out of response to first message
+        def parse_first_response(response)
+
+          # parse server response to first message
+          response_str = response.env.response_headers['www-authenticate']
+          unless response_str.index('scram ') == 0
+            throw 'Invalid response from server'
+          end
+          response_str.slice! 'scram '
+          response_vars = {}
+          response_str.split(', ').each do |pair|
+            key,value = pair.split('=')
+            response_vars[key] = value
+          end
+          unless response_vars['hash'] == 'SHA-256'
+            throw "Server requested unsupported hash algorithm: #{response_vars['hash']}"
+          end
+
+          # todo check handshake token (should be base64 encode of username)
+
+          @server_first_msg = Base64.decode64(response_vars["data"])
+          server_vars = {}
+          @server_first_msg.split(',').each do |pair|
+            key,value = pair.split '='
+            server_vars[key] = value
+          end
+          @server_nonce = server_vars['r']
+          @server_salt = server_vars['s'] #Base64.decode64(server_vars['s'])
+          @server_iterations = server_vars['i'].to_i
+        end
+
+        def send_second_message
+          res = connection.get('about') do |req|
+            req.headers['Authorization'] = "SCRAM handshakeToken=#{@handshake_token},data=#{Base64.strict_encode64(client_final).tr('=','')}"
+          end
+          res
+          
+        end
+        def parse_second_response(response)
+          begin
+            response_str = response.env.response_headers['authentication-info']
+            response_vars = {}
+            response_str.split(', ').each do |pair|
+              key,value = pair.split('=')
+              response_vars[key] = value
+            end
+            # decode data attribute to check server signature is as expected
+            key,val = Base64.decode64(response_vars['data']).split('=')
+            response_vars[key] = val
+            server_sig = response_vars['v']
+            unless server_sig == expected_server_signature
+              throw "invalid signature from server"
+            end
+            @auth_token = response_vars['authToken']
+          # rescue Exception => e
+          #   raise
+          end
+          
+        end
+
+        def test_auth_token
+          res = connection.get('about') do |req|
+            req.headers['Authorization'] = "BEARER authToken=#{@auth_token}"
+          end
+        end
+
+        private
+
+# utility methods, closely matched with SCRAM notation and algorithm overview here: 
+# https://tools.ietf.org/html/rfc5802#section-3
+
+        def auth_message
+          @auth_message ||= "#{first_message},#{@server_first_msg},#{without_proof}"
+        end
+
+        def client_final
+          @client_final ||= "#{without_proof},p=" +
+            client_proof(client_key, client_signature(stored_key(client_key), auth_message))
+        end
+
+        def client_key
+          @client_key ||= hmac(salted_password, 'Client Key')
+        end
+
+        def client_proof(key, signature)
+          @client_proof ||= Base64.strict_encode64(xor(key, signature))
+        end
+
+        def client_signature(key, message)
+          @client_signature ||= hmac(key, message)
+        end
+
+        def expected_server_key
+          @server_key ||= hmac(salted_password, 'Server Key')
+        end
+
+        def expected_server_signature
+          @server_signature ||= Base64.strict_encode64(hmac(expected_server_key, auth_message)).tr('=','')
+        end
+
+        def first_message
+          "n=#{@user.username},r=#{@nonce}"
+        end
+
+        def h(string)
+          @digest.digest(string)
+        end
+
+        def hi(data)
+          OpenSSL::PKCS5.pbkdf2_hmac(
+            data, 
+            Base64.decode64(@server_salt), 
+            @server_iterations, 
+            @digest.digest_length,
+            @digest
+          )
+        end
+
+        def hmac(data, key)
+          OpenSSL::HMAC.digest(@digest,data,key)
+        end
+
+
+        def salted_password
+          @salted_password ||= hi(@user.password)
+        end
+
+        def stored_key(key)
+          h(key)
+        end
+
+        def without_proof
+          @without_proof ||= "c=biws,r=#{@server_nonce}"
+        end
+
+        def xor(first, second)
+          first.bytes.zip(second.bytes).map{ |(a,b)| (a ^ b).chr }.join('')
+        end
+      end
+    end
+  end
+end

data/lib/haystack_ruby/config.rb

@@ -0,0 +1,22 @@
+module HaystackRuby
+  module Config
+    extend self
+    attr_accessor :projects
+
+    def load_configuration conf
+      @projects = {}
+      conf.each do |name, config|
+        p = Project.new(name, config)
+        @projects[name] = p if p.valid?
+      end
+    end
+
+    # called in railtie
+    def load!(path, environment = nil)
+      require 'yaml'
+      environment ||= Rails.env
+      conf = YAML.load(File.new(path).read).with_indifferent_access[environment]
+      load_configuration(conf)
+    end
+  end
+end

data/lib/haystack_ruby/error.rb

@@ -0,0 +1,5 @@
+module HaystackRuby
+  class Error < StandardError
+
+  end
+end

data/lib/haystack_ruby/object.rb

@@ -0,0 +1,70 @@
+require 'haystack_ruby/types/bin'
+require 'haystack_ruby/types/coord'
+require 'haystack_ruby/types/date'
+require 'haystack_ruby/types/date_time'
+require 'haystack_ruby/types/marker'
+require 'haystack_ruby/types/n_a'
+require 'haystack_ruby/types/number'
+require 'haystack_ruby/types/ref'
+require 'haystack_ruby/types/str'
+require 'haystack_ruby/types/time'
+require 'haystack_ruby/types/uri'
+
+module HaystackRuby
+  class Object
+    # Always present
+    attr_reader :value, :haystack_type
+    # May be present, depending on type
+    attr_reader :unit, :description
+    # initialize with a encoded json string
+    def initialize val
+      case val
+        when Array
+          @haystack_type = "Array" #may want to decode array components?
+          @value = val
+        when TrueClass
+          @haystack_type = "Boolean"
+          @value = val
+        when FalseClass
+          @haystack_type = "Boolean"
+          @value = val
+        when NilClass
+          @haystack_type = 'Null'
+          @value = val
+        when String
+          # Map to Haystack type per http://project-haystack.org/doc/Json
+          case val
+            when /\Am:.*/
+              include HaystackRuby::Types::Marker
+            when /\Az:.*/
+              include HaystackRuby::Types::NA
+            when /\An:.*/
+              extend HaystackRuby::Types::Number
+            when /\Ar:.*/
+              include HaystackRuby::Types::Ref
+            when /\As:.*/
+              include HaystackRuby::Types::Str
+            when /\Ad:.*/
+              include HaystackRuby::Types::Date
+            when /\Ah:.*/
+              include HaystackRuby::Types::Time
+            when /\At:.*/
+              include HaystackRuby::Types::DateTime
+            when /\Au:.*/
+              include HaystackRuby::Types::Uri
+            when /\Ab:.*/
+              include HaystackRuby::Types::Bin
+            when /\Ac:.*/
+              include HaystackRuby::Types::Coord
+            when /\Ax:.*/
+              raise HaystackRuby::Error, "parsing of XStr type is not supported for string val #{val}"
+            else
+              raise HaystackRuby::Error, "unrecognized type for string val #{val}"
+          end
+        else
+          raise HaystackRuby::Error, "unrecognized type for val #{val}"
+        end
+      set_fields val
+    end
+  end
+end

data/lib/haystack_ruby/point.rb

@@ -0,0 +1,80 @@
+require 'date'
+# require 'active_support'
+module HaystackRuby
+  module Point
+    
+    # is this Point valid for purposees of Project Haystack Integration?  
+    def haystack_valid?
+      return self.haystack_project_name.present? && self.haystack_point_id.present? && self.haystack_time_zone.present?
+    end
+
+    def haystack_project
+      @project ||= HaystackRuby::Config.projects[self.haystack_project_name]
+    end
+
+    def connection
+      haystack_project.connection
+    end
+
+    def his_read(range)
+      query = ["ver:\"#{haystack_project.haystack_version}\"",'id,range',"@#{self.haystack_point_id},\"#{range}\""]
+      pp query.join "\n"
+      res = connection.post('hisRead') do |req|
+        req.headers['Content-Type'] = 'text/plain'
+        req.body = query.join("\n")
+      end
+      JSON.parse! res.body
+    end
+
+    def meta_data
+      # read request on project to load current info, including tags and timezone
+      res = haystack_project.read({:id => "@#{self.haystack_point_id}"})['rows'][0]
+    end
+
+    # data is ascending array of hashes with format: {time: epochtime, value: myvalue}
+    def his_write(data)
+      query = 
+        ["ver:\"#{haystack_project.haystack_version}\" id:@#{self.haystack_point_id}",'ts,val'] + data.map{ |d| "#{d[:time]},#{d[:value]}"}
+
+      res = connection.post('hisWrite') do |req|
+        req.headers['Content-Type'] = 'text/plain'
+        req.body = query.join("\n")
+      end
+
+      JSON.parse(res.body)['meta']['ok'].present?
+    end
+
+    def data(start, finish = nil, as_datetime = false) # as_datetime currently ignored
+      return unless haystack_valid? #may choose to throw exception instead
+
+      range = [start]
+      range << finish unless finish.nil?
+      # clean up the range argument before passing through to hisRead
+      # ----------------
+      r = HaystackRuby::Range.new(range, self.haystack_time_zone)
+  
+      res = his_read r.to_s
+      reformat_timeseries(res['rows'], as_datetime)
+    end
+
+    def write_data(data)
+      # format data for his_write
+      data = data.map do |d| 
+        { 
+          time: HaystackRuby::Timestamp.convert_to_string(d[:time], self.haystack_time_zone),
+          value: d[:value]
+        }
+      end
+      his_write data
+    end
+
+    # map from 
+    def reformat_timeseries data, as_datetime
+      data.map do |d|
+        time = (as_datetime) ? DateTime.parse(d['ts']) : DateTime.parse(d['ts']).to_i
+        val = HaystackRuby::Object.new(d['val'])
+        {:time => time, :value => val.value}
+      end
+    end
+  end
+end

data/lib/haystack_ruby/project.rb

@@ -0,0 +1,159 @@
+module HaystackRuby
+  require 'json'
+  require 'pp'
+  # may consider making this a mixin instead
+  class Project
+    
+    attr_accessor :name, :haystack_version, :url #required
+    def initialize(name, config)
+      @name = name
+      @url = (config['secure']) ? 'https://' : 'http://'
+      @url = "#{@url}#{config['base_url']}"
+      @haystack_version = config['haystack_version']
+      # expect to use basic auth
+      if config['credentials'].present?
+        @credentials = config['credentials']
+       #for now at least, we fake the user object
+      #expect to use scram
+      else
+        user = OpenStruct.new
+        user.username = config['username']
+        user.password = config['password']
+        # @creds_path = config['credentials_path']
+        # creds = YAML.load File.new(@creds_path).read
+        # user.username = creds['username']
+        # user.password = creds['password']
+        authorize user
+      end
+    end
+
+    def authorize user
+      auth_conv = HaystackRuby::Auth::Scram::Conversation.new(user, @url)
+      auth_conv.authorize
+      @auth_token = auth_conv.auth_token
+      raise HaystackRuby::Error, "scram authorization failed" unless @auth_token.present?
+    end
+
+
+    # for now, setting up to have a single connection per project 
+    def connection
+      # if @credentials.nil? && @auth_token.nil?
+      #   authorize #will either set auth token or raise error
+      # end
+      @connection ||= Faraday.new(:url => @url) do |faraday|
+        faraday.request  :url_encoded             # form-encode POST params
+        faraday.response :logger                  # log requests to STDOUT
+        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+        faraday.headers['Authorization'] = @auth_token.present? ? "BEARER authToken=#{@auth_token}" : "Basic #@credentials"
+        faraday.headers['Accept'] = 'application/json' #TODO enable more formats
+      end
+    end
+
+    def read(params)
+      body = ["ver:\"#{@haystack_version}\""]
+      body << params.keys.join(',')
+      body << params.values.join(',')
+      res = self.connection.post('read') do |req|
+        req.headers['Content-Type'] = 'text/plain'
+        req.body = body.join("\n")
+      end
+      JSON.parse! res.body
+    end
+
+    # return meta data for all equip with related points
+    def equip_point_meta
+      # begin
+        equips = read({filter: '"equip"'})['rows']
+        puts equips
+        equips.map! do |eq|
+          eq.delete('disMacro')
+          eq['description'] = eq['id'].match(/[(NWTC)|(\$siteRef)] (.*)/)[1]
+          eq['id'] = eq['id'].match(/:([a-z0-9\-]*)/)[1]
+          eq['points'] = []
+          read({filter: "\"point and equipRef==#{eq['id']}\""})['rows'].each do |p|
+            p.delete('analytics')
+            p.delete('disMacro')
+            p.delete('csvUnit')
+            p.delete('csvColumn')
+            p.delete('equipRef')
+            p.delete('point')
+            p.delete('siteRef')
+
+            p['id'] = p['id'].match(/:([a-z0-9\-]*)/)[1]
+            p['name'] = p['navName']
+            p.delete('navName')
+            eq['points'] << p
+          end
+          eq
+        end
+      # rescue Exception => e
+        puts "error: #{e}"
+        nil
+      # end
+    end
+
+    def ops
+      JSON.parse!(self.connection.get("ops").body)['rows']
+    end
+
+    def valid?
+      !(@name.nil? || @haystack_version.nil? || @url.nil?)
+    end
+
+    # http://www.skyfoundry.com/doc/docSkySpark/Ops#commit
+    # grid is array of strings
+    def commit grid
+      puts 'grid = '
+      pp grid.join "\n"
+      res = self.connection.post('commit') do |req|
+        req.headers['Content-Type'] = 'text/plain'
+        req.body = grid.join "\n"
+      end
+      JSON.parse! res.body
+    end
+
+    # params is array of hashes: {name: xx, type: xx, value: xx}
+    def add_rec params
+      grid = ["ver:\"#{@haystack_version}\" commit:\"add\""]
+      grid << params.map{|p| p[:name]}.join(',')
+      values = params.map do |p|
+        p[:value] = "\"#{p[:value]}\"" if p[:type] == 'String'
+        p[:value]
+      end
+      grid << values.join(',')
+      res = commit grid 
+      # return id of new rec
+      res['rows'][0]['id']     
+    end
+
+# TODO fix these.  weird sensitivities around mod timestamp (format and time)
+    # params is array of hashes: {name: xx, type: xx, value: xx}
+    # def update_rec id,params
+      # grid = ["ver:\"#{@haystack_version}\" commit:\"update\""]
+      # grid << 'id,mod,' + params.map{|p| p[:name]}.join(',')
+      # values = params.map do |p|
+      #   p[:value] = "\"#{p[:value]}\"" if p[:type] == 'String'
+      #   p[:value]
+      # end
+      # grid << "#{id},2017-01-09T17:21:31.197Z UTC,#{values.join(',')}"
+      # puts "dumping grid #{grid}"
+      #
+      # commit grid
+    # end
+
+    def remove_rec id
+      grid = ["ver:\"#{@haystack_version}\" commit:\"remove\""]
+      grid << 'id,mod' 
+      grid << "#{id},#{DateTime.now}"
+      commit grid      
+    end
+    private
+
+    # def persist_creds
+    #   creds = {username: @username, password: @password, auth_token: @auth_token}
+    #   File.open(@creds_path,'w') do |h|
+    #     h.write creds.to_yaml
+    #   end
+    # end
+  end
+end

data/lib/haystack_ruby/railtie.rb

@@ -0,0 +1,18 @@
+require 'rails'
+module Rails
+  module HaystackRuby
+    class Railtie < Rails::Railtie
+        initializer "haystack_ruby.load-config" do
+        config_file = Rails.root.join("config", "haystack_ruby.yml")
+        if config_file.file?
+          begin
+            ::HaystackRuby::Config.load!(config_file)
+          rescue Exception => e
+            # TODO better error handling
+            puts "Error loading config for haystack_ruby: #{e}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/haystack_ruby/range.rb

@@ -0,0 +1,34 @@
+# from haystack docs:
+# 
+# Ranges are exclusive of start timestamp and inclusive of end timestamp. The {date} and {dateTime} options must be correctly Zinc encoded. DateTime based ranges must be in the same timezone of the entity (timezone conversion is explicitly disallowed). Date based ranges are always inferred to be from midnight of starting date to midnight of the day after ending date using the timezone of the his entity being queried.
+# ----------------
+
+
+module HaystackRuby
+  class Range
+    def initialize(range,time_zone)
+      @haystack_time_zone = time_zone
+      @finish = nil
+      if range.kind_of? Array 
+        raise HaystackRuby::Error, 'Too many values for range' if range.count > 2
+        @start = Timestamp.convert_to_string(range.first, time_zone) 
+        if range.count > 1
+          @finish = Timestamp.convert_to_string(range.last, time_zone)
+          raise HaystackRuby::Error, 'Start must be before End' if DateTime.parse(@start) >= DateTime.parse(@finish)
+        end
+      else
+        @start = Timestamp.convert_to_string(range, time_zone)
+      end
+    end
+
+    def to_s
+      if @finish
+        "#{@start},#{@finish}"
+      elsif @start
+        "#{@start}"
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/haystack_ruby/timestamp.rb

@@ -0,0 +1,20 @@
+module HaystackRuby
+  class Timestamp
+    # convert ts to a Project Haystack compliant string.
+    # ts is a timestamp, tz is a Haystack timezone string
+    # for now assumes application timezone is set correctly
+    # TODO add a mapping between Ruby and Haystack timezone strings and use here
+    def self.convert_to_string ts, tz
+      if ts.kind_of? DateTime
+        t = ts.to_s
+      elsif ts.kind_of? Integer
+        t = Time.at(ts).to_datetime.to_s
+      elsif ts.kind_of? Date
+        t = ts.to_datetime.to_s
+      else 
+        raise HaystackRuby::Error, "param must be one of Date, DateTime, Integer"
+      end
+      "#{t} #{tz}"
+    end
+  end
+end

data/lib/haystack_ruby/types/bin.rb

@@ -0,0 +1,13 @@
+module HaystackRuby
+  module Types
+    module Bin
+      def set_fields str_value
+        @haystack_type = 'Bin'
+        match = /\Ab:(.*)\z/.match str_value
+        raise HaystackRuby::Error, "invalid HaystackRuby::Types::Bin: #{str_value}" if match.nil?
+        # Value is mime type
+        @value = match[1]
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/coord.rb

@@ -0,0 +1,15 @@
+module HaystackRuby
+  module Types
+    module Coord
+      def set_fields str_value
+        @haystack_type = 'Coord'
+        match = /\Ac:([0-9.-]*),([0-9.-]*)\z/.match str_value
+        begin
+          @value = [match[1].to_f, match[2].to_f] #value is array of [lat, lng]
+        rescue Exception=>e
+          raise HaystackRuby::Error, "invalid HaystackRuby::Types::Coord #{str_value}.  Error #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/date.rb

@@ -0,0 +1,15 @@
+module HaystackRuby
+  module Types
+    module Date
+      def set_fields str_value
+        @haystack_type = 'Date'
+        match = /\Ad:([-0-9]*)\z/.match str_value
+        begin
+          @value = Date.parse match[1]
+        rescue Exception=>e
+          raise HaystackRuby::Error, "invalid HaystackRuby::Types::Date #{str_value}.  Error #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/date_time.rb

@@ -0,0 +1,15 @@
+module HaystackRuby
+  module Types
+    module DateTime
+      def set_fields str_value
+        @haystack_type = 'DateTime'
+        match = /\At:(.*)\z/.match str_value
+        begin
+          @value = DateTime.parse match[1]
+        rescue Exception=>e
+          raise HaystackRuby::Error, "invalid HaystackRuby::Types::DateTime #{str_value}.  Error #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/marker.rb

@@ -0,0 +1,10 @@
+module HaystackRuby
+  module Types
+    module Marker
+      def set_fields str_value
+        @haystack_type = 'Marker'
+        @value = true
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/n_a.rb

@@ -0,0 +1,10 @@
+module HaystackRuby
+  module Types
+    module NA
+      def set_fields str_value
+        @haystack_type = 'NA'
+        @value = 'NA'
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/number.rb

@@ -0,0 +1,14 @@
+module HaystackRuby
+  module Types
+    module Number
+      def set_fields str_value
+        @haystack_type = 'Number'
+        match = /\An:([-0-9\.]*)( .*)*\z/.match str_value
+        raise HaystackRuby::Error, "invalid HaystackRuby::Types::Number: #{str_value}" if match.nil?
+        @value = match[1].to_f
+        # also set unit if available
+        @unit = match[2].strip if match[2].present?
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/ref.rb

@@ -0,0 +1,13 @@
+module HaystackRuby
+  module Types
+    module Ref
+      def set_fields str_value
+        @haystack_type = 'Ref'
+        match = /\Ar:([^ ]*) (.*)\z/.match str_value
+        raise HaystackRuby::Error, HaystackRuby::Error, "invalid HaystackRuby::Types::Ref: #{str_value}" if match.nil?
+        @value = match[1] #ref id
+        @description = match[2]
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/str.rb

@@ -0,0 +1,12 @@
+module HaystackRuby
+  module Types
+    module Str
+      def set_fields str_value
+        @haystack_type = 'Str'
+        match = /\As:(.*)\z/.match str_value
+        raise "invalid HaystackRuby::Types::Str: #{str_value}" if match.nil?
+        @value = match[1]
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/time.rb

@@ -0,0 +1,16 @@
+module HaystackRuby
+  module Types
+    # Since there is no Ruby Hour class, value is a string "hr:minute"
+    module Time
+      def set_fields str_value
+        @haystack_type = 'Time'
+        match = /\Ah:([0-9:]*)\z/.match str_value
+        begin
+          @value = match[1]
+        rescue Exception=>e
+          raise HaystackRuby::Error, "invalid HaystackRuby::Types::Time #{str_value}.  Error #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/haystack_ruby/types/uri.rb

@@ -0,0 +1,12 @@
+module HaystackRuby
+  module Types
+    module Uri
+      def set_fields str_value
+        @haystack_type = 'Uri'
+        match = /\Au:(.*)\z/.match str_value
+        raise HaystackRuby::Error, "invalid HaystackRuby::Types::Uri: #{str_value}" if match.nil?
+        @value = match[1]
+      end
+    end
+  end
+end

data/lib/haystack_ruby.rb

@@ -0,0 +1,14 @@
+require 'faraday'
+require 'haystack_ruby/auth/conversation'
+require 'haystack_ruby/config'
+require 'haystack_ruby/error'
+require 'haystack_ruby/object'
+require 'haystack_ruby/point'
+require 'haystack_ruby/project'
+require 'haystack_ruby/range'
+require 'haystack_ruby/timestamp'
+
+require 'active_support/core_ext/hash'
+if defined?(Rails)
+  require "haystack_ruby/railtie"
+end

data/spec/haystack_ruby/auth/scram_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe HaystackRuby::Auth::Scram::Conversation do
+  describe 'connection' do
+
+    # it 'receives authorization challenge response to hello' do
+    #   expect(conv.hello.status.should == 401 )
+    # end
+    before :each do
+      user = OpenStruct.new
+      user.username = CONF[PROJECT]['username']
+      user.password = CONF[PROJECT]['password']
+      url = HaystackRuby::Config.projects[PROJECT].url
+      @conv = HaystackRuby::Auth::Scram::Conversation.new(user, url)
+    end
+    it 'receives auth challenge response to first message' do
+      expect(@conv.send_first_message.status).to be == 401
+    end
+    it 'sends valid rnonce in continue message' do
+      res = @conv.send_first_message
+      @conv.parse_first_response(res)
+      puts "nonce #{@conv.nonce}, servernonce #{@conv.server_nonce}"
+      expect(@conv.nonce.length).to be > 0 
+      expect(@conv.server_nonce.index(@conv.nonce)).to be == 0 
+    end
+    it 'server responds to second client message with authorization' do
+      res = @conv.send_first_message
+      @conv.parse_first_response(res)
+      expect(@conv.send_second_message.status).to be == 200
+    end
+    it 'should have nonempty auth token after full authorization' do
+      @conv.authorize
+      expect(@conv.auth_token).not_to be_empty
+    end
+    it 'should load page using auth token' do
+      @conv.authorize
+      expect(@conv.test_auth_token.status).to be == 200
+    end
+  end
+end

data/spec/haystack_ruby/config_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+describe HaystackRuby::Config do
+  describe '.projects' do
+    context 'good config file' do
+      before do
+        @projects = HaystackRuby::Config.projects
+        @demo = @projects[PROJECT]
+      end
+      it 'returns a project' do
+        expect(@demo).to be_a_kind_of HaystackRuby::Project
+      end
+    end
+    context 'bad project in config file' do
+    end
+    context 'missing config file' do
+    end
+  end
+end

data/spec/haystack_ruby/point_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'models/point_demo'
+describe HaystackRuby::Point do
+  before do
+    @point = PointDemo.new(PT_PROJ,PT_ID,PT_TZ)
+  end
+  describe '#haystack_project' do
+    context 'real project name' do
+      it 'responds to method' do
+        expect(@point).to respond_to :haystack_project
+      end
+      it 'returns a project' do
+        expect(@point.haystack_project).to be_a_kind_of HaystackRuby::Project
+      end
+    end
+  end
+  describe '#his_read' do
+    context 'valid id and range' do
+      before do
+        @res = @point.his_read('yesterday')
+      end
+      it 'returns 2 columns' do
+        expect(@res['cols'].count).to eq 2
+      end
+      it 'returns array of rows' do
+        expect(@res['rows']).to be_a_kind_of Array
+      end
+    end
+  end
+  describe '#his_write' do
+    context 'valid data' do
+      before do
+        data = [{time: "#{DateTime.now.to_s} #{@point.haystack_time_zone}", value: rand(-2000..2000).to_f / 10}, {time: "#{(DateTime.now - 1.day).to_s} #{@point.haystack_time_zone}", value: rand(-2000..2000).to_f / 10}]
+        @res = @point.his_write(data)
+      end
+      it 'returns true' do
+        expect(@res).to eq true
+      end
+    end
+  end
+  describe '#write_data' do
+    context 'valid data' do
+      before do
+        data = [{time: DateTime.now, value: -1}]
+        @res = @point.write_data(data)
+      end
+      it 'returns true' do
+        expect(@res).to eq true
+      end
+    end
+  end
+  
+  describe '#metadata' do
+    context 'valid id' do
+      it 'returns metadata for the point' do
+
+        expect(@point.meta_data).to be_a_kind_of Hash 
+      end
+    end
+  end
+
+  describe '#data' do
+    context 'valid id and range' do
+      before do
+        @data = @point.data(Date.today.prev_day)
+        @d = @data.first
+      end
+      it 'returns data with expected format' do
+        expect(@d[:time]).to_not be_nil
+        expect(@d[:value]).to_not be_nil
+      end
+      it 'returns time as epoch' do
+        expect(@d[:time]).to be_a_kind_of Integer
+      end
+    end
+    context 'as_datetime true' do
+      before do
+        @d = @point.data(Date.today.prev_day, nil, true).first
+      end
+      it 'returns time in DateTime format' do
+        expect(@d[:time]).to be_kind_of DateTime
+      end
+    end
+    context 'various range formats' do
+      context 'Dates' do
+        it 'returns data when two ascending Date values' do
+          data = @point.data(Date.today.prev_day, Date.today)
+          expect(data.count).to be > 0
+        end
+        it 'throws error start is after finish' do
+          expect {
+            data = @point.data(Date.today, Date.today.prev_day)
+          }.to raise_error HaystackRuby::Error
+        end
+        it 'returns data when no finish' do
+          data = @point.data(Date.today.prev_day)
+          expect(data.count).to be > 0
+        end
+      end
+      context 'Integers' do
+        it 'returns data when two ascending Integer values' do
+          data = @point.data(Date.today.prev_day.to_time.to_i, Date.today.to_time.to_i)
+          expect(data.count).to be > 0
+        end
+        it 'throws error start is after finish' do
+          expect {
+            data = @point.data(Date.today.to_time.to_i, Date.today.prev_day.to_time.to_i)
+          }.to raise_error HaystackRuby::Error
+        end
+        it 'returns data when no finish' do
+          data = @point.data(Date.today.prev_day.to_time.to_i)
+          expect(data.count).to be > 0
+        end
+      end
+      context 'DateTimes' do
+        it 'returns data when two ascending DateTime values' do
+          data = @point.data(Date.today.prev_day.to_datetime, Date.today.to_datetime)
+          expect(data.count).to be > 0
+        end
+        it 'throws error start is after finish' do
+          expect {
+            @point.data(Date.today.to_datetime, Date.today.prev_day.to_datetime)
+            }.to raise_error HaystackRuby::Error
+
+        end
+        it 'returns data when one value' do
+          data = @point.data(Date.today.prev_day.to_datetime)
+          expect(data.count).to be > 0
+        end
+      end
+      it 'returns data when range is Date' do
+        data = @point.data(Date.today.prev_day)
+        expect(data.count).to be > 0
+      end
+      it 'does not accept string values for range' do
+        expect { data = @point.data(Date.today.prev_day.to_s) }.to raise_error HaystackRuby::Error
+      end
+      it 'returns data when range is start DateTime' do
+        data = @point.data(Date.today.prev_day.to_datetime)
+        expect(data.count).to be > 0
+      end
+    end
+  end
+end

data/spec/haystack_ruby/project_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+describe HaystackRuby::Project do
+  before do
+    @demo = HaystackRuby::Config.projects[PT_PROJ]
+  end
+  describe '#connection' do
+    context 'defined project name' do
+      it 'returns valid Faraday connection' do
+        expect(@demo.connection).to be_a_kind_of Faraday::Connection
+      end
+      it 'sets Authorization header' do
+        expect(@demo.connection.headers['Authorization']).to_not be_nil
+      end
+      it 'accepts json' do
+        expect(@demo.connection.headers['Accept']).to eq 'application/json'
+      end
+    end
+    context 'undefined project name' do
+    end
+    context 'missing config file' do
+    end
+  end
+  describe '#read' do
+    context 'simple filter' do
+      it 'returns cols' do
+        expect(@demo.read({:filter => '"site"'})['cols']).to be_a_kind_of Array
+      end
+      it 'returns rows' do
+        expect(@demo.read({:filter => '"site"'})['rows']).to be_a_kind_of Array
+      end
+    end
+  end
+  describe '#add_rec' do
+    context 'point' do
+      it 'returns id' do
+        params = [{name: 'sp',type: 'Marker',value: 'M'},{name: 'dis',type: 'String',value: 'Test'},{name: 'point', type: 'Marker', value: 'M'},{name: 'equipRef',type: 'Ref',value: '@1d56759c-8f9214b6'},{name: 'siteRef', type: 'Ref', value: '@1d56758c-c15f5708'}]
+        res = @demo.add_rec(params )
+        expect(res).to be_a_kind_of String
+      end
+    end
+  end
+end

data/spec/models/point_demo.rb

@@ -0,0 +1,10 @@
+class PointDemo
+  # these fields are required on the class point is mixed into
+  attr_accessor :haystack_project_name, :haystack_point_id, :haystack_time_zone
+  include HaystackRuby::Point
+  def initialize(proj_name, point_id, tz)
+    @haystack_project_name = proj_name
+    @haystack_point_id = point_id
+    @haystack_time_zone = tz
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'bundler/setup'
+require 'yaml'
+Bundler.setup
+require 'haystack_ruby' # and any other gems you need
+
+# configuration constants used for testing
+CONFIG_PATH = 'config/example.yml' #path to the settings file, relative to directory root
+CONFIG_ENV = 'test' #environment to load from settings file for testing
+PROJECT = 'demov3' #name of project to use for testing.  Must match name in the settings file.
+PT_ID = '1d5675a8-867de4b8' #Haystack ID of an existing point that is safe for to use for testing. NOTE that this point will be written to.
+PT_PROJ = PROJECT # Optionally use a different project name for the point tests
+PT_TZ = 'Denver' # Timezone of your test point
+
+
+Time.zone='Mountain Time (US & Canada)'
+RSpec.configure do |config|
+  config.before(:suite) do
+    CONF = YAML.load(File.new(CONFIG_PATH).read).with_indifferent_access[CONFIG_ENV]
+    HaystackRuby::Config.load_configuration CONF
+  end
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: haystack_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anya Petersen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby adapter for Project Haystack REST API
+email: anya.petersen@nrel.gov
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/haystack_ruby.rb
+- lib/haystack_ruby/auth/conversation.rb
+- lib/haystack_ruby/config.rb
+- lib/haystack_ruby/error.rb
+- lib/haystack_ruby/object.rb
+- lib/haystack_ruby/point.rb
+- lib/haystack_ruby/project.rb
+- lib/haystack_ruby/railtie.rb
+- lib/haystack_ruby/range.rb
+- lib/haystack_ruby/timestamp.rb
+- lib/haystack_ruby/types/bin.rb
+- lib/haystack_ruby/types/coord.rb
+- lib/haystack_ruby/types/date.rb
+- lib/haystack_ruby/types/date_time.rb
+- lib/haystack_ruby/types/marker.rb
+- lib/haystack_ruby/types/n_a.rb
+- lib/haystack_ruby/types/number.rb
+- lib/haystack_ruby/types/ref.rb
+- lib/haystack_ruby/types/str.rb
+- lib/haystack_ruby/types/time.rb
+- lib/haystack_ruby/types/uri.rb
+- spec/haystack_ruby/auth/scram_spec.rb
+- spec/haystack_ruby/config_spec.rb
+- spec/haystack_ruby/point_spec.rb
+- spec/haystack_ruby/project_spec.rb
+- spec/models/point_demo.rb
+- spec/spec_helper.rb
+homepage: https://github.com/NREL/haystack_ruby
+licenses:
+- MIT
+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.6.11
+signing_key: 
+specification_version: 4
+summary: Project Haystack Ruby Adapter
+test_files:
+- spec/haystack_ruby/auth/scram_spec.rb
+- spec/haystack_ruby/config_spec.rb
+- spec/haystack_ruby/point_spec.rb
+- spec/haystack_ruby/project_spec.rb
+- spec/models/point_demo.rb
+- spec/spec_helper.rb