chawk 0.2.0 → 0.3.0

data/lib/node.rb

@@ -0,0 +1,313 @@
+require 'active_record'
+module Chawk
+  # Models used in Chawk.  ActiveRecord classes.
+  module Models
+    class NodeInvalidator
+      extend Forwardable
+      def_delegators :sweeps, :size, :map
+
+      def initialize(node)
+        @node = node
+        @sweeps = []
+        @ranges = []
+      end
+
+      def <<(time)
+        @node.ranges.where("start_ts <= ? AND stop_ts >= ?",time,time).each do |range|
+          @ranges << range.id unless @ranges.include?(range.id)
+        end
+      end
+
+      def invalidate!()
+        @ranges.each{|r|Chawk::Models::Range.find(r).populate!}
+      end
+    end
+
+    class NodeAggregator
+
+      attr_reader :dataset
+
+      def initialize(node)
+        node.check_read_access
+        if node.points.length > 0
+          @dataset = node.points.to_a.reduce([]) {|ary,p| ary << p.value}
+        end
+      end
+
+      def max()
+        @dataset.max
+      end
+
+      def min()
+        @dataset.min
+      end
+
+      def mean
+        sum.to_f / @dataset.length
+      end
+
+      def sum
+        @dataset.reduce(0) {|sum,p| sum+=p}
+      end
+
+      def count
+        @dataset.length
+      end
+
+      def sumsqr
+        @dataset.map {|x| x * x}.reduce(&:+)
+      end
+
+      def stdev
+        m = mean
+        Math.sqrt((sumsqr - count * m * m)/(count-1))
+      end
+    end
+
+    # The Node, where most Chawk:Node information is persisted..
+    class Node < ActiveRecord::Base
+      attr_accessor :agent
+      after_initialize :init
+      self.table_name_prefix = "chawk_"
+      belongs_to :agent
+      has_many :points
+      has_many :values
+      has_many :relations
+      has_many :ranges, foreign_key: :parent_node_id
+
+      attr_accessor :access
+
+      def init
+        @agent = nil
+      end
+
+      def clear_values!
+        check_admin_access
+        values.destroy_all
+      end
+
+      def clear_points!
+        check_admin_access
+        points.destroy_all
+      end
+
+      def _prepare_insert(val, ts, options)
+        values = {value:val,observed_at:ts.to_f}
+        if options[:meta]
+          if options[:meta].is_a?(Hash)
+            values[:meta] = options[:meta].to_json
+          else
+            raise ArgumentError, "Meta must be a JSON-representable Hash. #{options[:meta].inspect}"
+          end
+        end
+        values
+      end
+
+      def _insert_value(val,ts,options={})
+        self.values.create(_prepare_insert(val, ts, options))
+        ts
+      end
+
+      def value_recognizer(item, dt, options={})
+        case 
+        when item.is_a?(String)
+          _insert_value item,dt, options
+        else
+          raise ArgumentError, "Can't recognize format of data item. #{item.inspect}"
+        end
+      end
+
+      def _unravel(items)
+        if items.is_a?(Array)
+          items.each do |item|
+            yield item
+          end
+        else
+          yield items
+        end
+      end
+
+      def _add(args, type, options={})
+        check_write_access
+        ni = NodeInvalidator.new(self)
+        options[:observed_at] ? dt = options[:observed_at] : dt = Time.now
+        _unravel(args) do |arg|
+          case type
+          when :point
+            ni << point_recognizer(arg, dt, options)
+          when :value
+            ni << value_recognizer(arg, dt, options)
+          end
+        end
+        ni.invalidate!
+      end
+
+      # @param args [Object, Array of Objects]
+      # @param options [Hash] You can also pass in :meta and :timestamp 
+      # Add an item or an array of items (one at a time) to the datastore.
+      def add_values(args,options={})
+        _add(args,:value, options)
+      end
+
+      # @param args [Object, Array of Objects]
+      # @param options [Hash] You can also pass in :meta and :timestamp 
+      # Add an item or an array of items (one at a time) to the datastore.
+      def add_points(args,options={})
+        _add(args,:point,options)
+      end
+
+      def _insert_point(val,ts,options={})        
+        self.points.create(_prepare_insert(val, ts, options))
+        ts
+      end
+
+      def _insert_point_hash(item,ts,options)
+        if item['v'] && item['v'].is_a?(Integer)
+          if item['t']
+            _insert_point item['v'],item['t'], options
+          else
+            _insert_point item['v'],ts, options
+          end
+        else
+          raise ArgumentError, "Hash must have 'v' key set to proper type.. #{item.inspect}"
+        end
+      end
+
+      def _insert_point_array(item,options)
+        if item.length == 2 && item[0].is_a?(Integer)
+          _insert_point item[0],item[1], options
+        else
+          raise ArgumentError, "Array Items must be in [value,timestamp] format. #{item.inspect}"
+        end
+      end
+
+      def _insert_point_string(item,ts,options)
+        if item.length > 0 && item =~ /\A[-+]?[0-9]+/
+          _insert_point item.to_i,ts, options
+        else
+          raise ArgumentError, "String Items must represent Integer. #{item.inspect}"
+        end
+      end
+
+      def point_recognizer(item, dt, options={})
+        case 
+        when item.is_a?(Integer)
+          _insert_point item,dt, options
+        when item.is_a?(Array)
+          _insert_point_array(item, options)
+        when item.is_a?(Hash)
+          _insert_point_hash(item,dt,options)
+        when item.is_a?(String)
+          _insert_point_string(item,dt,options)
+        else
+          raise ArgumentError, "Can't recognize format of data item. #{item.inspect}"
+        end
+      end
+
+      def check_write_access
+        unless [:full,:admin,:write].include? @access
+          raise SecurityError,"You do not have write access to this node."
+        end
+      end
+
+      def check_read_access
+        unless [:full,:admin,:read].include? @access
+          raise SecurityError,"You do not have read access to this node."
+        end
+      end
+
+      def check_admin_access
+        unless [:full,:admin,:read].include? @access
+          raise SecurityError,"You do not have admin access to this node."
+        end
+      end
+
+      def increment(value=1, options={})
+        check_write_access
+        if value.is_a?(Integer)
+          last = self.points.last
+          add_points last.value + value,options 
+        else 
+          raise ArgumentError, "Value must be an Integer"
+        end
+      end
+
+      def decrement(value=1, options={})
+        check_write_access
+        if value.is_a?(Integer)
+          increment (-1) * value, options
+        else 
+          raise ArgumentError, "Value must be an Integer"
+        end
+      end
+
+      def _range(dt_from, dt_to, coll, options={})
+        check_read_access
+        ret = coll.where("observed_at >= :dt_from AND  observed_at <= :dt_to",{dt_from:dt_from.to_f,dt_to:dt_to.to_f}, limit:1000,order:"observed_at asc, id asc")
+      end
+
+      # Returns items whose observed_at times fit within from a range.
+      # @param dt_from [Time::Time] The start time.
+      # @param dt_to [Time::Time] The end time.
+      # @return [Array of Objects] 
+      def values_range(dt_from, dt_to,options={})
+        _range(dt_from, dt_to, values, options)
+      end
+
+      # Returns items whose observed_at times fit within from a range ending now.
+      # @param dt_from [Time::Time] The start time.
+      # @return [Array of Objects] 
+      def values_since(dt_from)
+        self.values_range(dt_from,Time.now)
+      end
+
+      # Returns items whose observed_at times fit within from a range.
+      # @param dt_from [Time::Time] The start time.
+      # @param dt_to [Time::Time] The end time.
+      # @return [Array of Objects] 
+      def points_range(dt_from, dt_to,options={})
+        _range(dt_from, dt_to, points, options)
+      end
+
+      # Returns items whose observed_at times fit within from a range ending now.
+      # @param dt_from [Time::Time] The start time.
+      # @return [Array of Objects] 
+      def points_since(dt_from)
+        self.points_range(dt_from,Time.now)
+      end
+
+      # Sets public read flag for this address 
+      # @param value [Boolean] true if public reading is allowed, false if it is not.
+      def set_public_read(value)
+        value = value ? true : false
+        self.update_attributes :public_read => value
+        #save
+      end
+
+      # Sets public write flag for this address 
+      # @param value [Boolean] true if public writing is allowed, false if it is not.
+      def set_public_write(value)
+        value = value ? true : false
+        self.update_attributes :public_write => value
+        #save
+      end
+
+      # Sets permissions flag for this address, for a specific agent.  The existing Chawk::Relationship will be destroyed and 
+      # a new one created as specified.  Write access is not yet checked.
+      # @param agent [Chawk::Agent] the agent to give permission.
+      # @param read [Boolean] true/false can the agent read this address.
+      # @param write [Boolean] true/false can the agent write this address. (Read acces is required to write.)
+      # @param admin [Boolean] does the agent have ownership/adnim rights for this address. (Read and write are granted if admin is as well.)
+      def set_permissions(agent,read=false,write=false,admin=false)
+        rels = relations.where(:agent_id => agent.id)
+        rels.delete_all()
+        rels = relations.where(:agent_id => agent.id)
+        if read || write || admin
+          vals = {agent:agent,read:(read ? true : false),write:(write ? true : false),admin:(admin ? true : false)}
+          relations.create(vals)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/range.rb

@@ -0,0 +1,70 @@
+require 'active_record'
+module Chawk
+  module Models
+    class Range < ActiveRecord::Base
+      self.table_name_prefix = "chawk_"
+      validates :start_ts, :stop_ts, :beats, :parent_node, presence:true
+      validates :subkey, :data_node, absence: true
+      validate :order_is_correct
+
+      before_create :build_subnode
+
+      after_create :build_dataset
+      after_find :grant_node_access
+
+      belongs_to :parent_node, class_name:"Chawk::Models::Node"
+      belongs_to :data_node, class_name:"Chawk::Models::Node"
+
+      def reload
+        super
+        grant_node_access
+      end
+
+      def grant_node_access
+        # TODO: vet this very carefully.
+        # The only way to get here should be through an authorized source.
+        self.data_node.access=:full
+      end
+
+      def build_subnode
+        if subkey.to_s == ''
+          self.subkey = parent_node.key + "/" + SecureRandom.hex.to_s
+        end
+        self.data_node = Chawk::Models::Node.create(key:subkey)
+        grant_node_access
+      end
+
+      def order_is_correct
+        if self.start_ts >= self.stop_ts
+          errors.add(:stop_ts, "must be after start_ts.")
+        end
+      end
+
+      def build_dataset
+        populate!
+      end
+
+      def point_from_parent_point(now)
+        point = parent_node.points.where("observed_at <= :dt_to",{dt_to:now}).order(observed_at: :desc, id: :desc).first
+        if point
+          value = point.value
+        else
+          value = default || 0
+        end
+        data_node.points.create(observed_at:now, recorded_at:Time.now, value:value)
+      end
+
+      def populate!
+        # TODO: Accounting hook
+        # TODO: perform in callback (celluloid?)
+        self.data_node.points.destroy_all
+        step = 0.25 * self.beats
+        now = (self.start_ts*4).round/4.to_f
+        while now < self.stop_ts
+          point = point_from_parent_point now
+          now += step
+        end
+      end
+    end
+  end
+end

data/test/lib/addr_test.rb

@@ -5,58 +5,88 @@ describe Chawk do
   before do
     Chawk.clear_all_data!
     @agent =  Chawk::Models::Agent.first || Chawk::Models::Agent.create(:name=>"Test User")
-    @addr = Chawk.addr(@agent,'a:b')
+    @node = Chawk.node(@agent,'a:b')
   end
 
   it "has a good agent" do
-    lambda {@addr = Chawk.addr(nil,'a:b')}.must_raise(ArgumentError)
-    lambda {@addr = Chawk.addr(Object.new,'a:b')}.must_raise(ArgumentError)
-    lambda {@addr = Chawk.addr(Chawk::Models::Agent,'a:b')}.must_raise(ArgumentError)
+    lambda {Chawk.node(nil,'a:b')}.must_raise(ArgumentError)
+    lambda {Chawk.node(Object.new,'a:b')}.must_raise(ArgumentError)
+    lambda {Chawk.node(Chawk::Models::Agent,'a:b')}.must_raise(ArgumentError)
+    node = Chawk.node(@agent,'a:b').key.must_equal("a:b")
+    agent2 =  Chawk::Models::Agent.first || Chawk::Models::Agent.create(:name=>"Test User")
+    node = Chawk.node(agent2,'a:b').key.must_equal("a:b")
+    agent3 =  Chawk::Models::Agent.create(:name=>"Test Failer")
+    lambda{Chawk.node(agent3,'a:b').key.must_equal("a:b")}.must_raise(SecurityError)
   end
 
   it "has key" do
-   @addr.must_respond_to(:key)
+   @node.must_respond_to(:key)
   end
 
   it "key is valid" do
-    @addr.key.must_equal("a:b")
-    Chawk.addr(@agent,'a:b').key.must_equal("a:b")
-    Chawk.addr(@agent,'0:x:z').key.must_equal("0:x:z")
+    @node.key.must_equal("a:b")
+    Chawk.node(@agent,'a:b').key.must_equal("a:b")
+    Chawk.node(@agent,'0:x:z').key.must_equal("0:x:z")
     path = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345689_:$!@*[]~()"
-    Chawk.addr(@agent,path).key.must_equal(path)
+    Chawk.node(@agent,path).key.must_equal(path)
   end
 
   it "rejects invalid paths" do
-    lambda {Chawk.addr(@agent,['A'])}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,0)}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,:a)}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,Object.new)}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,String.new)}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,"")}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,"/")}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,"\\")}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,"&")}.must_raise(ArgumentError)
-    lambda {Chawk.addr(@agent,"?")}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,['A'])}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,0)}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,:a)}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,Object.new)}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,String.new)}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,"")}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,"/")}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,"\\")}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,"&")}.must_raise(ArgumentError)
+    lambda {Chawk.node(@agent,"?")}.must_raise(ArgumentError)
   end
 
   it "sets permissions" do
-    @addr.must_respond_to(:set_public_read)
-    @addr.must_respond_to(:set_permissions)
+    @node.must_respond_to(:set_public_read)
+    @node.must_respond_to(:set_permissions)
   end
 
   it "stops unauthorized access" do
-    agent2 = Chawk::Models::Agent.where("name=?","Steve Austin").first || Chawk::Models::Agent.create(name:"Steve Austin")
-    lambda{@addr = Chawk.addr(agent2,'a:b')}.must_raise SecurityError
-    @addr.set_public_read true
-    Chawk.addr(agent2,'a:b').key.must_equal "a:b"
-    @addr.set_public_read false
-    lambda{@addr = Chawk.addr(agent2,'a:b')}.must_raise SecurityError
-    @addr.set_permissions(agent2,true,false,false)
-    Chawk.addr(agent2,'a:b').key.must_equal "a:b"
-    @addr.set_permissions(agent2,false,false,false)
-    lambda{@addr = Chawk.addr(agent2,'a:b')}.must_raise SecurityError
-    @addr.set_permissions(agent2,false,false,true)
-    Chawk.addr(agent2,'a:b').key.must_equal "a:b"
+    @node.set_permissions(@agent,true,false,false)
+    @node = Chawk::Models::Node.find(@node.id)
+    lambda{Chawk.node(@agent,'a:b')}.must_raise SecurityError
+    @node.set_permissions(@agent,false,false,false)
+    lambda{Chawk.node(@agent,'a:b')}.must_raise SecurityError
+  end
+
+  it "stops unauthorized reads" do
+    @node.set_permissions(@agent,false,false,false)
+    lambda{Chawk.node(@agent,'a:b', :write)}.must_raise SecurityError
+    @node.set_public_read true
+    Chawk.node(@agent,'a:b', :read).key.must_equal "a:b"
+    @node.set_public_read false
+    lambda{Chawk.node(@agent,'a:b', :read)}.must_raise SecurityError
+    @node.set_permissions(@agent,true,true,false)
+    w_node = Chawk.node(@agent,'a:b', :write)
+    lambda{w_node.values_range(0,0)}.must_raise SecurityError
+  end
+
+  it "stops unauthorized writes" do
+    @node.set_permissions(@agent,true,false,false)
+    lambda{Chawk.node(@agent,'a:b', :write)}.must_raise SecurityError
+    @node.set_public_write true
+    Chawk.node(@agent,'a:b', :write).key.must_equal "a:b"
+    @node.set_public_write false
+    lambda{Chawk.node(@agent,'a:b', :write)}.must_raise SecurityError
+    r_node = Chawk.node(@agent,'a:b', :read)
+    lambda{r_node.add_points([1,2,3,4])}.must_raise SecurityError
+  end
+
+  it "stops unauthorized admin" do
+    @node.set_permissions(@agent,false,false,false)
+    lambda{Chawk.node(@agent,'a:b', :admin)}.must_raise SecurityError
+    @node.set_permissions(@agent,false,true,true)
+    Chawk.node(@agent,'a:b', :admin).key.must_equal "a:b"
+    w_node = Chawk.node(@agent,'a:b', :write)
+    lambda{w_node.clear_points!}.must_raise SecurityError
   end
 
 end

data/test/lib/failed_node_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 require 'json'
 
 Jiggy = Chawk.clone 
-def Jiggy.find_or_create_node(agent,key) return nil end
+def Jiggy.find_or_create_node(agent,key,access=:full) return nil end
 
 describe Jiggy do
   before do
@@ -12,7 +12,7 @@ describe Jiggy do
 
   it "needs a valid node" do
 
-    lambda {@addr = Jiggy.addr(@agent,'a:b')}.must_raise(ArgumentError)
+    lambda {@node = Jiggy.node(@agent,'a:b')}.must_raise(ArgumentError)
   end
 
 end