saal 0.2.25 → 0.3.4

data/lib/dinrelay.rb

@@ -29,7 +29,7 @@ module SAAL
 
     class OutletGroup
       DEFAULT_TIMEOUT = 2
-      DEFAULT_CACHE_TIMEOUT = 60
+      DEFAULT_CACHE_TIMEOUT = 5
 
       attr_accessor :host, :port, :user, :pass, :timeout, :cache_timeout
 
@@ -42,6 +42,7 @@ module SAAL
         @cache_timeout = opts[:cache_timeout] || opts['cache_timeout'] || DEFAULT_CACHE_TIMEOUT
         @cache = nil
         @cachehit = nil
+        @cachetime = nil
       end
 
       def state(num)
@@ -60,25 +61,8 @@ module SAAL
 
       private
       def do_get(path)
-        begin
-          http = Net::HTTP.new(@host,@port)
-          # Timeout faster when the other side doesn't respond
-          http.open_timeout = @timeout
-          http.read_timeout = @timeout
-          req = Net::HTTP::Get.new(path)
-          req.basic_auth @user, @pass
-          response = http.request(req)
-          if response.code != "200"
-            #$stderr.puts "ERROR: Code #{response.code}"
-            #$stderr.puts response.body
-            return nil
-          end
-          return response
-        rescue Exception
-          return nil
-        end
+        SAAL::do_http_get(@host, @port, path, @user, @pass, @timeout)
       end
-
       def parse_index_html(str)
         doc = Nokogiri::HTML(str)
         outlets = doc.css('tr[bgcolor="#F4F4F4"]')

data/lib/envoy.rb

@@ -0,0 +1,287 @@
+require 'json'
+
+module SAAL
+  module Envoy
+    class PowerEnergyUnderlying < SensorUnderlying
+      def initialize(key, production)
+        @key = key
+        @production = production
+      end
+
+      def read(uncached = false)
+        @production.read_val(@key)
+      end
+    end
+
+    class PowerEnergy
+      DEFAULT_HOST = "envoy.local"
+      DEFAULT_TIMEOUT = 2
+      DEFAULT_CACHE_TIMEOUT = 5
+      DEFAULT_SOURCES = [
+        "production_inverters",
+        "production_phase1", "production_phase2", "production_phase3", "production_total",
+        "net_consumption_phase1", "net_consumption_phase2", "net_consumption_phase3", "net_consumption_total",
+        "total_consumption_phase1", "total_consumption_phase2", "total_consumption_phase3", "total_consumption_total",
+      ]
+      DEFAULT_TYPES = [
+        "w_now", "wh_lifetime", "va_now", "vah_lifetime",
+      ]
+      DEFAULT_PREFIX = "pv"
+
+      def initialize(defs, opts={})
+        @host = defs[:host] || defs['host'] || DEFAULT_HOST
+        @timeout = opts[:timeout] || opts['timeout'] || DEFAULT_TIMEOUT
+        @cache_timeout = opts[:cache_timeout] || opts['cache_timeout'] || DEFAULT_CACHE_TIMEOUT
+        @cache = nil
+        @cachetime = nil
+        @sources = defs[:sources] || defs['source'] || DEFAULT_SOURCES
+        @types = defs[:types] || defs['types'] || DEFAULT_TYPES
+        @prefix = defs[:prefix] || defs['prefix'] || DEFAULT_PREFIX
+      end
+
+      def read_val(name)
+        if !@cachetime or @cachetime < Time.now - @cache_timeout
+          @cache = read_all()
+          @cachetime = Time.now
+        end
+        return @cache ? @cache[name] : nil
+      end
+
+      def create_sensors
+        sensors = {}
+        @sources.product(@types).each do |source, type|
+          key = "#{@prefix}_#{source}_#{type}"
+          sensors[key] = PowerEnergyUnderlying.new(key, self)
+        end
+        sensors
+      end
+
+      private
+      def save_vals(dest, name, source)
+        {
+         "wNow" => "w_now",
+         "apprntPwr" => "va_now",
+         "whLifetime" => "wh_lifetime",
+         "vahLifetime" => "vah_lifetime",
+        }.each do |type, label|
+          dest["#{@prefix}_#{name}_#{label}"] = source[type]
+        end
+
+        # Hack around the fact that apprntPwr is broken on the total consumption
+        # calculation for the three-phase sum at least
+        # In those cases it seems to be missing a divide by three, so when the
+        # calculation for voltage and current alone is close do the extra divide
+        va_now = dest["#{@prefix}_#{name}_va_now"]
+        if va_now && !name.include?("phase")
+          voltage = source["rmsVoltage"]
+          current = source["rmsCurrent"]
+          if voltage && current
+            va_alt = voltage * current
+            if ((va_alt / va_now) - 1.0).abs < 0.05
+              dest["#{@prefix}_#{name}_va_now"] = va_now / 3.0
+            end
+          end
+        end
+      end
+
+      def read_all
+        response = SAAL::do_http_get(@host, 80, "/production.json?details=1", nil, nil, @timeout)
+        return nil if !response
+
+        values = JSON.parse(response.body)
+        outputs = {}
+
+        values["production"].each do |source|
+          type = source["type"]
+          case type
+          when "inverters"
+            save_vals(outputs, "production_inverters", source)
+          when "eim"
+            if source["lines"]
+              save_vals(outputs, "production_phase1", source["lines"][0])
+              save_vals(outputs, "production_phase2", source["lines"][1])
+              save_vals(outputs, "production_phase3", source["lines"][2])
+            end
+            save_vals(outputs, "production_total", source)
+          else
+            $stderr.puts "WARNING: ENVOY: don't know source type #{type}"
+          end
+        end
+
+        values["consumption"].each do |source|
+          type = {
+            "total-consumption" => "total",
+            "net-consumption" => "net",
+          }[source["measurementType"]] || "unknown";
+
+          if source["lines"]
+            save_vals(outputs, "#{type}_consumption_phase1", source["lines"][0])
+            save_vals(outputs, "#{type}_consumption_phase2", source["lines"][1])
+            save_vals(outputs, "#{type}_consumption_phase3", source["lines"][2])
+          end
+          save_vals(outputs, "#{type}_consumption_total", source)
+        end
+
+        outputs
+      end
+    end
+
+    class ACQualityUnderlying < SensorUnderlying
+      def initialize(key, production)
+        @key = key
+        @production = production
+      end
+
+      def read(uncached = false)
+        @production.read_val(@key)
+      end
+    end
+
+    class ACQuality
+      DEFAULT_HOST = "envoy.local"
+      DEFAULT_TIMEOUT = 2
+      DEFAULT_CACHE_TIMEOUT = 5
+      DEFAULT_SOURCES = ["total","phase1","phase2","phase3",]
+      DEFAULT_TYPES = ["frequency","voltage"]
+      DEFAULT_PREFIX = "ac"
+
+      def initialize(defs, opts={})
+        @host = defs[:host] || defs['host'] || DEFAULT_HOST
+        @timeout = opts[:timeout] || opts['timeout'] || DEFAULT_TIMEOUT
+        @cache_timeout = opts[:cache_timeout] || opts['cache_timeout'] || DEFAULT_CACHE_TIMEOUT
+        @cache = nil
+        @cachetime = nil
+        @sources = defs[:sources] || defs['source'] || DEFAULT_SOURCES
+        @types = defs[:types] || defs['types'] || DEFAULT_TYPES
+        @prefix = defs[:prefix] || defs['prefix'] || DEFAULT_PREFIX
+      end
+
+      def read_val(name)
+        if !@cachetime or @cachetime < Time.now - @cache_timeout
+          @cache = read_all()
+          @cachetime = Time.now
+        end
+        return @cache ? @cache[name] : nil
+      end
+
+      def create_sensors
+        sensors = {}
+        @sources.product(@types).each do |source, type|
+          key = "#{@prefix}_#{source}_#{type}"
+          sensors[key] = ACQualityUnderlying.new(key, self)
+        end
+        sensors
+      end
+
+      private
+      def save_vals(dest, name, source)
+        {
+         "voltage" => "voltage",
+         "freq" => "frequency",
+        }.each do |type, label|
+          dest["#{@prefix}_#{name}_#{label}"] = source[type]
+        end
+      end
+
+      def read_all
+        response = SAAL::do_http_get(@host, 80, "/ivp/meters/readings", nil, nil, @timeout)
+        return nil if !response
+
+        values = JSON.parse(response.body)
+        outputs = {}
+        source = values[0]
+        save_vals(outputs, "total", source)
+        if source["channels"]
+          save_vals(outputs, "phase1", source["channels"][0])
+          save_vals(outputs, "phase2", source["channels"][1])
+          save_vals(outputs, "phase3", source["channels"][2])
+        end
+
+        outputs
+      end
+    end
+
+    class InverterUnderlying < SensorUnderlying
+      def initialize(key, inverters)
+        @key = key
+        @inverters = inverters
+      end
+
+      def read(uncached = false)
+        @inverters.read_val(@key)
+      end
+    end
+
+    class Inverters
+      DEFAULT_TIMEOUT = 2
+      DEFAULT_CACHE_TIMEOUT = 50
+      DEFAULT_SOURCES = []
+      DEFAULT_TYPES = ["w_now"] # "last_report_date", "w_max"
+      DEFAULT_USER = nil
+      DEFAULT_PASSWORD = nil
+      DEFAULT_PREFIX = "inverters"
+      attr_reader :inverters
+
+      def initialize(defs, opts={})
+        @host = defs[:host] || defs['host'] || DEFAULT_HOST
+        @user = defs[:user] || defs['user'] || DEFAULT_USER
+        @password = defs[:password] || defs['password'] || DEFAULT_PASSWORD
+        @timeout = opts[:timeout] || opts['timeout'] || DEFAULT_TIMEOUT
+        @cache_timeout = opts[:cache_timeout] || opts['cache_timeout'] || DEFAULT_CACHE_TIMEOUT
+        @cache = nil
+        @cachetime = nil
+        @inverters_list = {}
+        @inverters = defs[:inverters] || defs['inverters'] || DEFAULT_SOURCES
+        @types = defs[:types] || defs['types'] || DEFAULT_TYPES
+        @prefix = defs[:prefix] || defs['prefix'] || DEFAULT_PREFIX
+      end
+
+      def read_val(name)
+        if !@cachetime or @cachetime < Time.now - @cache_timeout
+          @cache = read_all()
+          @cachetime = Time.now
+        end
+        return @cache ? @cache[name] : nil
+      end
+
+      def enumerate
+        read_val("foo") # Force a read to make sure the inverter serials are stored
+        @inverters_list.keys
+      end
+
+      def set_all_inverters!
+        @inverters = self.enumerate
+      end
+
+      def create_sensors
+        sensors = {}
+        @inverters.product(@types).each do |source, type|
+          key = "#{@prefix}_#{source}_#{type}"
+          sensors[key] = InverterUnderlying.new(key, self)
+        end
+        sensors
+      end
+
+      private
+      def read_all
+        response = SAAL::do_http_get_digest(@host, 80, "/api/v1/production/inverters", @user, @password, @timeout)
+        return nil if !response
+
+        values = JSON.parse(response.body)
+        inverters = {}
+        values.each do |inverter|
+          serial = inverter["serialNumber"]
+          @inverters_list[serial] = true
+          {"lastReportDate" => "last_report_date",
+           "lastReportWatts" => "w_now",
+           "maxReportWatts" => "w_max",
+          }.each do |type, label|
+            inverters["#{@prefix}_#{serial}_#{label}"] = inverter[type]
+          end
+        end
+
+        inverters
+      end
+    end
+  end
+end

data/lib/http.rb

@@ -0,0 +1,51 @@
+require 'uri'
+require 'net/http'
+require 'net/http/digest_auth'
+
+def SAAL::do_http_get(host, port, path, user, pass, timeout)
+  begin
+    http = Net::HTTP.new(host,port)
+    # Timeout faster when the other side doesn't respond
+    http.open_timeout = timeout
+    http.read_timeout = timeout
+    req = Net::HTTP::Get.new(path)
+    req.basic_auth(user, pass) if user && pass
+    response = http.request(req)
+    if response.code != "200"
+      #$stderr.puts "ERROR: Code #{response.code}"
+      #$stderr.puts response.body
+      return nil
+    end
+    return response
+  rescue Exception
+    return nil
+  end
+end
+
+def SAAL::do_http_get_digest(host, port, path, user, pass, timeout)
+  begin
+    uri = URI.parse "http://#{host}:#{port}/#{path}"
+    digest_auth = Net::HTTP::DigestAuth.new
+    uri.user = user
+    uri.password = pass
+    http = Net::HTTP.new(host,port)
+    # Timeout faster when the other side doesn't respond
+    http.open_timeout = timeout
+    http.read_timeout = timeout
+    req = Net::HTTP::Get.new(path)
+    response = http.request(req)
+    if response.code == "401" && user && pass
+      auth = digest_auth.auth_header uri, response['www-authenticate'], 'GET'
+      req.add_field 'Authorization', auth
+      response = http.request(req)
+    end
+    if response.code != "200"
+      #$stderr.puts "ERROR: Code #{response.code}"
+      #$stderr.puts response.body
+      return nil
+    end
+    return response
+  rescue Exception
+    return nil
+  end
+end

data/lib/outliercache.rb

@@ -41,7 +41,7 @@ module SAAL
     def valid_cache
       @compcache.sort!
       central = @compcache[1..(@compcache.size-2)]
-      sum = central.inject(0.0){|sum,el| sum+el}
+      sum = central.inject(0.0){|csum,el| csum+el}
       return false if sum == 0.0
       average = sum/central.size
       central.each do |el|

data/lib/saal.rb

@@ -1,5 +1,5 @@
 require 'yaml'
-require "mysql"
+require "mysql2"
 require 'ownet'
 require 'nokogiri'
 require 'erb'
@@ -10,7 +10,7 @@ module SAAL
     DBCONF = CONFDIR+"database.yml"
     CHARTSCONF = CONFDIR+"charts.yml"
 
-    VERSION = '0.2.25'
+    VERSION = '0.3.4'
 end
 
 require File.dirname(__FILE__)+'/dbstore.rb'
@@ -23,4 +23,7 @@ require File.dirname(__FILE__)+'/chart.rb'
 require File.dirname(__FILE__)+'/chart_data.rb'
 require File.dirname(__FILE__)+'/outliercache.rb'
 require File.dirname(__FILE__)+'/dinrelay.rb'
+require File.dirname(__FILE__)+'/envoy.rb'
+require File.dirname(__FILE__)+'/http.rb'
+require File.dirname(__FILE__)+'/denkovi.rb'
   

data/lib/sensor.rb

@@ -72,6 +72,11 @@ module SAAL
       apply_offset @dbstore.average(@name, from, to)
     end
 
+    def weighted_average(from, to)
+      return @mock_opts[:weighted_average] if @mock_opts[:weighted_average]
+      apply_offset @dbstore.weighted_average(@name, from, to)
+    end
+
     def minimum(from, to)
       return @mock_opts[:minimum] if @mock_opts[:minimum]
       apply_offset @dbstore.minimum(@name, from, to)

data/lib/sensors.rb

@@ -40,9 +40,38 @@ module SAAL
           defs.merge!('name' => outlet_descriptions[num])
           Sensor.new(dbstore, oname, DINRelay::Outlet.new(num.to_i, og), defs, opts)
         end
+      elsif defs['envoy_power_energy']
+        defs = defs['envoy_power_energy'].merge('prefix' => name)
+        pe = SAAL::Envoy::PowerEnergy::new(defs)
+        sensors = pe.create_sensors
+        return sensors.map do |name, underlying|
+          Sensor.new(dbstore, name, underlying, defs, opts)
+        end
+      elsif defs['envoy_ac_quality']
+        defs = defs['envoy_ac_quality'].merge('prefix' => name)
+        pe = SAAL::Envoy::ACQuality::new(defs)
+        sensors = pe.create_sensors
+        return sensors.map do |name, underlying|
+          Sensor.new(dbstore, name, underlying, defs, opts)
+        end
+      elsif defs['envoy_inverters']
+        defs = defs['envoy_inverters'].merge('prefix' => name)
+        pe = SAAL::Envoy::Inverters::new(defs)
+        sensors = pe.create_sensors
+        return sensors.map do |name, underlying|
+          Sensor.new(dbstore, name, underlying, defs, opts)
+        end
+      elsif defs['denkovi']
+        defs = defs['denkovi'].merge('prefix' => name)
+        denkovi = SAAL::Denkovi::OutletGroup::new(defs)
+        sensors = denkovi.create_sensors
+        return sensors.map do |name, vals|
+          underlying, description = vals
+          defs.merge!('name' => description)
+          Sensor.new(dbstore, name, underlying, defs, opts)
+        end
       else
-        raise UnknownSensorType, "Couldn't figure out a valid sensor type "
-                                 "from the configuration for #{name}"
+        $stderror.puts "WARNING: Couldn't figure out a valid sensor type for #{name}"
       end
     end
   end