saal 0.2.2

data/Rakefile

@@ -0,0 +1,160 @@
+# Based on the jekyll Rakefile (http://github.com/mojombo/jekyll)
+
+require 'rubygems'
+require 'rake'
+require 'date'
+require 'rcov/rcovtask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end
+
+Rcov::RcovTask.new(:coverage) do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.rcov_opts << ['--exclude "^/"', '--include "lib/.*\.rb"']
+  t.output_dir = 'coverage'
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+desc "Prints code to test ratio stats"
+task :stats do
+  CODE_FILES = "lib/**/*.rb"
+  TEST_FILES = "test/*_test.rb"
+
+  code_code, code_comments = count_lines(FileList[CODE_FILES])
+  test_code, test_comments = count_lines(FileList[TEST_FILES])
+  
+  puts "Code lines: #{code_code} code, #{code_comments} comments"
+  puts "Test lines: #{test_code} code, #{test_comments} comments"
+  
+  ratio = test_code.to_f/code_code.to_f
+  
+  puts "Code to test ratio: 1:%.2f" % ratio
+end
+
+def count_lines(files)
+  code = 0
+  comments = 0
+  files.each do |f| 
+    File.open(f).each do |line|
+      if line.strip[0] == '#'[0]
+        comments += 1
+      else
+        code += 1
+      end
+    end
+  end
+  [code, comments]
+end
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "git tag, build and release gem"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build gem"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+task :gemspec do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg|coverage)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end

data/TODO

@@ -0,0 +1,24 @@
+TODO
+- Add logging to the daemon
+?- Change the sensor configuration to be a ruby DSL and make it a daemon config
+- Split classes into one per file with corresponding test (rails style)
+- Verify inputs on the server to make sure it never crashes
+- Remove the chart configuration options from the saal_chart script
+- Add an init.d file to the package (and possibly an installer script for ubuntu/debian)
+- Add outlier detection and removal
+DONE
+X- Make the server bind only to a certain interface (not applicable)
+X- Override OWNet::Connection with a mock object so that owserver is not needed
+X- Implement GET_ALL
+X- Multithread the server
+X- Make connections persistant
+- Find a better way to handle stdin, stdout, stderr for tests (an option maybe)
+- Implement the charts
+- Write client library for server part of daemon
+- Implement AVERAGE
+- Make sensor reads uncached
+- Refactor daemon.rb to pull out its daemon creating code from the process 
+- Create a client/server framework to ask the server for values
+- Make the date returned by GET the date of the last read (GET doesn't return
+  a date now
+- Implement monthly, yearly and 10-day average charts

data/bin/.gitignore

@@ -0,0 +1,2 @@
+sensor_reads_ulisses.db
+sensors_ulisses.yml

data/bin/dinrelayset

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+def exit_usage
+  $stderr.puts "Usage: dinrelayset <host:[port]> <port 1-8> <ON|OFF> [user:password]"
+  exit 2
+end
+
+if ARGV.size > 4 || ARGV.size < 3
+  exit_usage
+end
+
+opts = {}
+
+hp = ARGV[0].split(":")
+opts[:host] = hp[0]
+opts[:port] = (hp[1] || 80).to_i
+
+num = ARGV[1].to_i
+exit_usage if num < 1 || num > 8 
+state = ARGV[2]
+exit_usage if state != 'ON' && state != 'OFF' 
+
+if ARGV[4]
+  up = ARGV[4].split(":")
+  exit_usage if up.size != 2
+  opts[:user] = up[0]
+  opts[:pass] = up[1]
+end
+
+puts "Setting outlet #{num} of #{opts[:host]}:#{opts[:port]} to #{state}"
+og = SAAL::DINRelay::OutletGroup.new(opts)
+og.set_state(num, state)
+

data/bin/dinrelaystatus

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+def exit_usage
+  $stderr.puts "Usage: dinrelaystatus <host:[port]> [user:password]"
+  exit 2
+end
+
+if ARGV.size > 2 || ARGV.size < 1
+  exit_usage
+end
+
+opts = {}
+
+hp = ARGV[0].split(":")
+opts[:host] = hp[0]
+opts[:port] = (hp[1] || 80).to_i
+
+if ARGV[1]
+  up = ARGV[1].split(":")
+  exit_usage if up.size != 2
+  opts[:user] = up[0]
+  opts[:pass] = up[1]
+end
+
+puts "Checking outlets for #{opts[:host]}:#{opts[:port]}"
+og = SAAL::DINRelay::OutletGroup.new(opts)
+(1..8).each do |num| 
+  puts "Outlet \##{num}: #{og.state(num).to_s}"
+end
+

data/bin/saal_chart

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+def usage
+  $stderr.puts("Usage: saal_chart <day|week|4week|year|4year> <chart_file.png>")
+end
+
+if ARGV.size != 2
+  usage
+  exit (2)
+end
+
+@now = Time.now.utc
+
+NUM_VALUES = 500
+case ARGV[0]
+when 'day' then
+  PERIODNAMES = (0..23).map{|i| ((@now.hour - i)%24).to_s}.reverse
+  ALIGNMENT = :hour 
+  NUMDAYS = 1
+  ALIGNNAMES = :center
+when 'week' then
+  daynames = ["Seg","Ter","Qua","Qui","Sex","Sab","Dom"]
+  PERIODNAMES = (1..7).map{|i| (@now.wday - i)%7}.map{|w| daynames[w]}.reverse
+  ALIGNMENT = :day 
+  NUMDAYS = 7
+  ALIGNNAMES = :center
+when '4week' then
+  monthnames = ["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Sep","Out","Nov","Dez"]
+  initial = @now.to_i - (@now.wday-1)*24*60*60
+  PERIODNAMES = (0...4).map do |i| 
+    time = Time.at(initial - i*24*60*60*7)
+    time.day.to_s+" "+ monthnames[time.month-1]
+  end.reverse
+  ALIGNMENT = :week
+  NUMDAYS = 28
+  ALIGNNAMES = :left
+when 'year' then
+  monthnames = ["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Sep","Out","Nov","Dez"]
+  initial = @now.to_i - (@now.wday-1)*24*60*60
+  PERIODNAMES = (1..12).map{|i| (@now.month - i)%12}.map{|m| monthnames[m]}.reverse
+  ALIGNMENT = :month
+  NUMDAYS = 356
+  ALIGNNAMES = :center
+when '4year' then
+  PERIODNAMES = (0..3).map{|i| (@now.year - i).to_s}.reverse
+  ALIGNMENT = :year
+  NUMDAYS = 356*3
+  ALIGNNAMES = :center
+else
+  usage
+  exit(3)
+end
+NUMPERIODS = PERIODNAMES.size
+
+align = {:year => [12,31,23,59,59],
+         :month => [31,23,59,59],
+         :day => [23,59,59],
+         :week => [23,59,59],
+         :hour => [59,59]}
+
+args = [@now.year, @now.month, @now.day, @now.hour, @now.min, @now.sec]
+args = args[0..-(align[ALIGNMENT].size+1)]
+args += align[ALIGNMENT]
+@to = Time.utc(*args).to_i
+@to += (6-@now.wday)*60*60*24 if ALIGNMENT == :week
+@from = @to - 60*60*24*NUMDAYS
+
+@sensors = SAAL::Sensors.new
+def create_data(sensor, min, max, constant=0)
+  @c = SAAL::ChartData.new(@sensors.send(sensor))
+  d = @c.get_data(@from, @to, NUM_VALUES)
+  d = d.map{|num| num ? num+constant : num}
+  @c.normalize_data(d,min,max)
+end
+
+@data = [create_data('temp_exterior', -15, 45),
+         create_data('temp_estufa', -15, 45),
+         create_data('hum_exterior', 0, 100),
+         create_data('pressao', 950, 1050, 0.54*33.86)] #Convert to pressure at sea level
+
+
+@dataurl = @data.map {|values| values.join(",")}.join('|')
+
+r = {}
+case ALIGNNAMES
+when :center
+  @periodnamesurl = "||"+PERIODNAMES.join('||')+"||"
+when :left
+  @periodnamesurl = "|"+PERIODNAMES.join('|')+"||"
+  r[:chxs] = "0,555555,11,-1,lt"
+end
+@xincr = 100.0/NUMPERIODS.to_f*10000.truncate.to_f/10000
+
+r[:chof] = "png"
+r[:chs] = "700x300"
+r[:cht] = "lc"
+r[:chco] = "00ff00,ff0000,0000ff,ffff00"
+r[:chxt] = "x,y,y,r"
+r[:chxl] = "0:#{@periodnamesurl}1:|-15ºC||0||15||30||45ºC|2:|0%|25|50|75|100%|3:|950||975||1000||1025||1050 hPa"
+r[:chg] = "#{@xincr},12.5,1,5"
+r[:chd] = "t:#{@dataurl}"
+
+@url = "http://chart.apis.google.com/chart?&"
+@postdata = r.map{|k,v| k.to_s+"="+v}.join("&")
+
+
+system "wget --quiet \"#{@url}\" --post-data=\"#{@postdata}\" -O #{ARGV[1]}"
+

data/bin/saal_daemon

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+SENSOR_INTERVAL = 60 # seconds between consecutive measurements of the sensors
+DBCONF = "/etc/saal/database.yml"
+SENSORSCONF = "/etc/saal/sensors.yml"
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+if ARGV.size != 1
+  $stderr.puts "Usage: saal_daemon [pidfile]"
+  exit 2
+else
+  pidfile = ARGV[0]  
+  d = SAAL::Daemon.new(:interval => SENSOR_INTERVAL,
+                       :sensorconf => SENSORSCONF,
+                       :dbconf => DBCONF)
+  pid = d.run
+  File.open(pidfile, 'w') do |f|
+    f.write(pid)
+    f.close
+  end
+end

data/bin/saal_dump_database

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+if ARGV.size != 0
+  puts "Usage: saal_dump_database"
+  exit 2
+else
+  dbstore = SAAL::DBStore.new
+  dbstore.each {|sensor,date,value| puts "#{sensor} #{date} #{value}"}
+end

data/bin/saal_import_mysql

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby 
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+begin
+  dbstore = SAAL::DBStore.new
+  
+  nrows = 0
+  while not $stdin.eof?
+    values = $stdin.readline.split(" ").map{|s| s.strip}
+    if values[2] != ""
+      dbstore.write(values[0], values[1].to_i, values[2].to_f)
+      nrows += 1
+    end
+  end
+  puts "Number of rows inserted: #{nrows}"
+end
+

data/bin/saal_readall

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__)+'/../lib/saal.rb'
+
+if ARGV.size > 0
+  $stderr.puts "saal_readall takes no arguments"
+  exit 2
+else
+  SAAL::Sensors.new.each{|s| puts "#{s.name}: #{s.read.to_s}"}
+end

data/lib/chart_data.rb

@@ -0,0 +1,30 @@
+module SAAL
+  class ChartData
+    def initialize(sensor)
+      @sensor = sensor
+    end
+    
+    def get_data(from, to, num)
+      step = (to - from).to_f/num.to_f
+      (0..num-2).map do |i|
+        f = (from+i*step).to_i
+        t = (from+(i+1)*step-0.5).to_i
+        @sensor.average(f, t)
+      end << @sensor.average((from+(num-1)*step).to_i, to)
+    end
+    
+    def normalize_data(data, min, max)
+      data.map do |i|
+        if i.nil?
+          -1.0
+        elsif i < min
+          0.0
+        elsif i > max
+          100.0
+        else
+          v = (((i-min)/(max-min).to_f)*1000).round/10.0
+        end
+      end
+    end
+  end
+end

data/lib/daemon.rb

@@ -0,0 +1,63 @@
+module SAAL
+  class ForkedRunner
+    def self.run_as_fork(opts={})
+      fork do
+        if not opts[:keep_stdin]
+          $stderr.reopen "/dev/null", "a"
+          $stdin.reopen "/dev/null", "a"
+          $stdout.reopen "/dev/null", "a"
+        end
+        yield ForkedRunner.new
+      end
+    end
+    
+    def initialize
+      @rd, @wr = IO.pipe
+      @stop = false
+      trap_signals
+    end
+    
+    def trap_signals
+      Signal.trap("TERM") {do_exit}
+      Signal.trap("INT") {do_exit}
+    end
+    
+    def do_exit
+      @stop = true
+      @wr.write(1) 
+    end
+    
+    def stop?
+      @stop
+    end
+    
+    def sleep(time)
+      select([],[],[],time)
+    end
+    
+    def select(read, write=[], err=[], time=nil)
+      if time
+        Kernel.select(read+[@rd],write,err,time)
+      else
+        Kernel.select(read+[@rd],write,err)
+      end
+    end
+  end
+
+  class Daemon
+    def initialize(opts={})
+      @opts = opts
+    end
+
+    def run
+      ForkedRunner.run_as_fork(@opts) do |forked_runner|
+        @sensors = SAAL::Sensors.new(@opts[:sensorconf], @opts[:dbconf])
+        @interval = @opts[:interval] || 60
+        begin
+          @sensors.each {|sensor| sensor.store_value}
+          forked_runner.sleep @interval
+        end while !forked_runner.stop?
+      end
+    end
+  end
+end

data/lib/dbstore.rb

@@ -0,0 +1,86 @@
+module SAAL
+  class DBStore
+    include Enumerable
+    def initialize(conffile=SAAL::DBCONF)
+      @dbopts = YAML::load(File.new(conffile))
+      @db = nil
+      db_initialize
+    end
+
+    def db_initialize
+      db_query "CREATE TABLE IF NOT EXISTS sensor_reads
+                   (sensor VARCHAR(100), 
+                    date INT, 
+                    value FLOAT,
+                    INDEX USING HASH (sensor),
+                    INDEX USING BTREE (date))"
+    end
+    
+    def db_wipe
+      db_query "DROP TABLE sensor_reads"
+    end
+
+    def write(sensor, date, value)
+      raise ArgumentError, "Trying to store an empty sensor read" if !value
+      raise ArgumentError, "Trying to store an empty timestamp" if !date
+      raise ArgumentError, "Trying to store a timestamp <= 0" if date <= 0
+      db_query "INSERT INTO sensor_reads VALUES
+                  ('"+db_quote(sensor.to_s)+"',"+date.to_s+","+value.to_s+")"
+    end
+    
+    def average(sensor, from, to)     
+      db_range("AVG", sensor, from, to)
+    end
+
+    def minimum(sensor, from, to)     
+      db_range("MIN", sensor, from, to)
+    end
+    def maximum(sensor, from, to)     
+      db_range("MAX", sensor, from, to)
+    end
+
+    def each
+      db_query "SELECT sensor,date,value FROM sensor_reads" do |r|
+        r.num_rows.times do
+          row = r.fetch_row
+          yield [row[0],row[1].to_i, row[2].to_f]
+        end
+      end
+    end
+    
+    private
+    def db_range(function, sensor, from, to)
+      db_query "SELECT #{function}(value) AS average FROM sensor_reads
+                       WHERE sensor = '#{db_quote(sensor.to_s)}' 
+                         AND date >= #{from.to_s} 
+                         AND date <= #{to.to_s}" do |r|
+        if r.num_rows == 0 
+          nil
+        else
+          row = r.fetch_row
+          row[0] ? row[0].to_f : nil
+        end
+      end
+    end
+
+    def db_quote(text)
+      Mysql.quote(text)
+    end
+
+    def db_query(query)
+      db = nil
+      begin
+        # connect to the MySQL server
+        db = Mysql.new(@dbopts['host'],@dbopts['user'],@dbopts['pass'],
+                       @dbopts['db'],@dbopts['port'],@dbopts['socket'],
+                       @dbopts['flags'])
+        res = db.query(query)
+        yield res if block_given?
+      rescue Mysql::Error => e
+        $stderr.puts "MySQL Error \#{e.errno}: \#{e.error}"
+      ensure
+        db.close if db
+      end
+    end      
+  end
+end

data/lib/dinrelay.rb

@@ -0,0 +1,67 @@
+require 'net/http'
+
+module SAAL
+  module DINRelay
+    class Outlet < SensorUnderlying
+      writeable!
+
+      def initialize(num, outletgroup)
+        @num = num
+        @og = outletgroup
+      end
+
+      def read(uncached = false)
+        {'ON' => 1.0, 'OFF' => 0.0}[@og.state(@num)]
+      end
+
+      def write(value)
+        newstate = {1.0 => 'ON', 0.0 => 'OFF'}[value]
+        if newstate
+          @og.set_state(@num,newstate)
+          value 
+        end
+      end
+    end
+
+    class OutletGroup
+      def initialize(opts={})
+        @host = opts[:host] || opts['host'] || 'localhost'
+        @port = opts[:port] || opts['port'] || 80
+        @user = opts[:user] || opts['user'] || 'admin'
+        @pass = opts[:pass] || opts['pass'] || '1234'
+      end
+
+      def state(num)
+        response = do_get('/index.htm')
+        return parse_index_html(response.body)[num]
+      end
+
+      def set_state(num, state)
+        response = do_get("/outlet?#{num}=#{state}")
+        response.code == "200"
+      end
+
+      private
+      def do_get(path)
+        Net::HTTP.start(@host,@port) do |http|
+          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
+          end
+          return response
+        end
+      end
+
+      def parse_index_html(str)
+        doc = Nokogiri::HTML(str)
+        outlets = doc.css('tr[bgcolor="#F4F4F4"]')
+        Hash[*((outlets.enum_for(:each_with_index).map do |el, index|
+          [index+1, el.css('font')[0].content]
+        end).flatten)]
+      end
+    end
+  end
+end