omf_web 0.9.7 → 0.9.8

data/lib/omf-web/rack/session_authenticator.rb

@@ -3,31 +3,57 @@ require 'omf_common/lobject'
 require 'rack'
 require 'omf-web/session_store'
 
-      
-module OMF::Web::Rack      
+
+module OMF::Web::Rack
+  class AuthenticationFailedException < Exception
+
+  end
+
+  # This rack module maintains a session cookie and
+  # redirects any requests to protected pages to a
+  # 'login' page at the beginning of a session
+  #
+  # Calls to the class methods are resolved inthe context
+  # of a Session using 'OMF::Web::SessionStore'
+  #
   class SessionAuthenticator < OMF::Common::LObject
-    
+
+    # Returns true if this Rack module has been instantiated
+    # in the current Rack stack.
+    #
     def self.active?
       @@active
     end
 
+    # Return true if the session is authenticated
+    #
     def self.authenticated?
-      self[:authenticated]
+      debug "AUTH: #{self[:authenticated] == true}"
+      self[:authenticated] == true
     end
 
+    # Calling this method will authenticate the current session
+    #
     def self.authenticate
       self[:authenticated] = true
       self[:valid_until] = Time.now + @@expire_after
     end
-    
+
+    # Logging out will un-authenticate this session
+    #
     def self.logout
+      debug "LOGOUT"
       self[:authenticated] = false
     end
 
+    # DO NOT CALL DIRECTLY
+    #
     def self.[](key)
       OMF::Web::SessionStore[key, :authenticator]
     end
-    
+
+    # DO NOT CALL DIRECTLY
+    #
     def self.[]=(key, value)
       OMF::Web::SessionStore[key, :authenticator] = value
     end
@@ -35,10 +61,12 @@ module OMF::Web::Rack
     @@active = false
     # Expire authenticated session after being idle for that many seconds
     @@expire_after = 2592000
-    
+
     #
     # opts -
-    #   :no_session - Array of regexp to ignore
+    #   :login_url - URL to redirect if session is not authenticated
+    #   :no_session - Array of regexp on 'path_info' which do not require an authenticated session
+    #   :expire_after - Idle time in sec after which to expire a session
     #
     def initialize(app, opts = {})
       @app = app
@@ -49,45 +77,49 @@ module OMF::Web::Rack
       end
       @@active = true
     end
-    
-    
+
+    def check_authenticated
+      authenticated = self.class[:authenticated] == true
+      #puts "AUTHENTICATED: #{authenticated}"
+      raise AuthenticationFailedException.new unless authenticated
+      #self.class[:valid_until] = Time.now + @@expire_after
+
+    end
+
     def call(env)
       #puts env.keys.inspect
       req = ::Rack::Request.new(env)
-      sid = nil
       path_info = req.path_info
-      #puts "REQUEST: #{path_info}"
+      unless sid = req.cookies['sid']
+        sid = "s#{(rand * 10000000).to_i}_#{(rand * 10000000).to_i}"
+      end
+      Thread.current["sessionID"] = sid  # needed for Session Store
       unless @opts[:no_session].find {|rx| rx.match(path_info) }
-        sid = req.cookies['sid'] || "s#{(rand * 10000000).to_i}_#{(rand * 10000000).to_i}"
-        debug "Setting session for '#{req.path_info}' to '#{sid}'"
-        Thread.current["sessionID"] = sid
-        # If 'login_url' is defined, check if this session is authenticated
-        login_url = @opts[:login_url] 
+
+        # If 'login_page_url' is defined, check if this session is authenticated
+        login_url = @opts[:login_page_url]
         if login_url && login_url != req.path_info
-          if authenticated = self.class[:authenticated]
-            # Check if it hasn't imed out
-            if self.class[:valid_until] < Time.now
-              debug "Session '#{sid}' expired"
-              authenticated = false
-            end    
-          end
-          unless authenticated
-            return [301, {'Location' => login_url, "Content-Type" => ""}, ['Login first']]
+          begin
+            check_authenticated
+          rescue AuthenticationFailedException => ex
+            if err = self.class[:login_error]
+              login_url = login_url + "?msg=#{err}"
+            end
+            headers = {'Location' => login_url, "Content-Type" => ""}
+            Rack::Utils.set_cookie_header!(headers, 'sid', sid)
+            return [301, headers, ['Login first']]
           end
         end
-        self.class[:valid_until] = Time.now + @@expire_after
       end
-            
+
       status, headers, body = @app.call(env)
-      if sid
-        headers['Set-Cookie'] = "sid=#{sid}"  ##: name2=value2; Expires=Wed, 09-Jun-2021 ]
-      end
-      [status, headers, body]      
+      Rack::Utils.set_cookie_header!(headers, 'sid', sid) if sid
+      [status, headers, body]
     end
   end # class
-  
+
 end # module
 
 
-      
-        
+
+

data/lib/omf-web/rack/tab_mapper.rb

@@ -57,11 +57,12 @@ module OMF::Web::Rack
         comp_name = ((@opts[:tabs] || [])[0] || {})[:id]
       end
       comp_name = comp_name.to_sym if comp_name
+      #puts "PATH: #{path} - #{comp_name}"
       comp_name
     end
     
     def render_card(req)
-      #puts ">>>> REQ: #{req.script_name}::#{req.inspect}"
+      #puts ">>>> REQ: #{req.path_info}::#{req.inspect}"
       
       opts = @opts.dup
       opts[:prefix] = req.script_name

data/lib/omf-web/rack/websocket_handler.rb

@@ -2,6 +2,7 @@
 require 'rack/websocket'
 require 'omf_common/lobject'
 require 'omf-web/session_store'
+require 'thread'
 
 module OMF::Web::Rack
   
@@ -9,6 +10,9 @@ module OMF::Web::Rack
     include OMF::Common::Loggable
     extend OMF::Common::Loggable 
     
+    MESSAGE_DELAY = 0.5 # Delay in pushing action message to browser 
+                        # after receiving a 'on_change' from monitored data proxy 
+    
     def on_open(env)
       #puts ">>>>> OPEN"
     end   
@@ -36,7 +40,6 @@ module OMF::Web::Rack
         debug "#{ex.backtrace.join("\n")}"
         send_data({type: 'reply', status: 'exception', err_msg: ex.to_s}.to_json)
       end
-      #puts "message processed"      
     end
   
     def on_close(env)
@@ -53,17 +56,53 @@ module OMF::Web::Rack
       dsp = find_data_source(args)
       return unless dsp  # should define appropriate exception
       debug "Received registration for datasource proxy '#{dsp}'"
+      send_data({type: 'reply', status: 'ok'}.to_json)
+      
+      mutex = Mutex.new
+      semaphore = ConditionVariable.new
+      action_queue = {}
+      
       dsp.on_changed(args['offset']) do |action, rows|
-        msg = {
-          type: 'datasource_update',
-          datasource: dsp.name,
-          rows: rows,
-          action: action
-          #offset: offset
-        }
-        send_data(msg.to_json)
+        mutex.synchronize do
+          (action_queue[action] ||= []).concat(rows)
+          semaphore.signal
+        end
       end
-      send_data({type: 'reply', status: 'ok'}.to_json)
+      
+      # Send the rows in a separate thread, waiting a bit after the first one arriving
+      # to 'bunch' things into more manageable number of messages
+      Thread.new do
+        begin 
+          loop do 
+            # Now lets send them
+            mutex.synchronize do
+              action_queue.each do |action, rows|
+                next if rows.empty?
+                debug "Sending '#{action}' message with #{rows.length} rows"
+                msg = {
+                  type: 'datasource_update',
+                  datasource: dsp.name,
+                  rows: rows,
+                  action: action
+                  #offset: offset
+                }
+                send_data(msg.to_json)
+                rows.clear
+              end
+
+              # wait until there is more to send
+              semaphore.wait(mutex)
+            end
+            
+            # OK, there is something to do, but let's wait a bit, maybe there is more
+            sleep MESSAGE_DELAY
+          end
+        rescue Exception => ex
+          error "on_register_data_source - #{ex}"
+          debug "#{ex.backtrace.join("\n")}"
+        end
+      end
+      
     end
     
     # args {"slice"=>{"col_name"=>"id", "col_value"=>"e8..."}, "ds_name"=>"individual_link"}}

data/lib/omf-web/session_store.rb

@@ -19,20 +19,21 @@ module OMF::Web
       self.session["#{domain}:#{key}"] = value
     end
 
-    def self.session(sid = nil)
-      unless sid
-        sid = Thread.current["sessionID"]
-      end
-      unless sid
-        raise "Missing session id 'sid'"
-      end
-      
+    def self.session()
+      sid = session_id
       session = @@sessions[sid] ||= {:content => {}}
       #puts "STORE>> #{sid} = #{session[:content].keys.inspect}"
       session[:ts] = Time.now
       session[:content]
     end    
     
+    def self.session_id
+      sid = Thread.current["sessionID"]
+      unless sid
+        raise "Missing session id 'sid'"
+      end
+    end
+    
     def self.find_tab_from_path(comp_path)
       sid = comp_path.shift
       unless session = self.session(sid)

data/lib/omf-web/theme/bright/page.rb

@@ -114,7 +114,7 @@ module OMF::Web::Theme
         widget(Erector.inline(&@footer_right))
       else
         span :style => 'float:right;margin-right:10pt' do
-          text @footer_right || OMF::Web::VERSION
+          text @footer_right || "omf-web V#{OMF::Web::VERSION}"
         end
       end
       if @footer_left.is_a? Proc

data/lib/omf-web/thin/runner.rb

@@ -73,9 +73,13 @@ module OMF::Web
       if ph = @options[:handlers][:pre_parse]
         ph.call(p)
       end
-      
-      parse!
 
+      parse!
+      # WHY IS THIS HERE
+      # unless life_cycle(:post_parse)
+        # puts p.to_s
+        # abort()
+      # end
       if sopts
         @options[:ssl] = true
         @options[:ssl_key_file] ||= sopts[:key_file]
@@ -96,14 +100,23 @@ module OMF::Web
       @@instance = self
     end
     
-    def life_cycle(step)
+    def life_cycle(step, &exception_block)
       begin
         if (p = @options[:handlers][step])
           p.call()
         end
       rescue => ex
-        error ex
-        debug "#{ex.backtrace.join("\n")}"
+        if exception_block
+          begin 
+            exception_block.call(ex)
+          rescue => ex2
+            error ex2
+            debug "#{ex2.backtrace.join("\n")}"
+          end
+        else
+          error ex
+          debug "#{ex.backtrace.join("\n")}"
+        end
       end
     end    
     

data/lib/omf-web/version.rb

@@ -1,7 +1,7 @@
 
 module OMF
   module Web
-    VERSION = '0.9.7'
+    VERSION = '0.9.8'
     # Used for finding the example directory
     TOP_DIR = File.dirname(File.dirname(File.dirname(__FILE__)))
   end

data/lib/omf-web/widget/text/maruku/output/to_html.rb

@@ -43,6 +43,7 @@ module MaRuKu; module Out; module HTML
 	
 	# Render as an HTML fragment (no head, just the content of BODY). (returns a string)
 	def to_html(context={})
+	  Thread.current['maruku_context'] = context
 		indent = context[:indent] || -1
 		ie_hack = context[:ie_hack] || true
 		
@@ -803,6 +804,7 @@ of the form `#ff00ff`.
 				 " Using SPAN element as replacement."
 				return wrap_as_element('span')
 		end
+    raise "IMAGE: #{url}"
 		return a
 	end
 	
@@ -813,10 +815,14 @@ of the form `#ff00ff`.
 				" Using SPAN element as replacement."
 			return wrap_as_element('span')
 		end
+		if url_resolver = (Thread.current['maruku_context'] || {})[:img_url_resolver]
+		  url = url_resolver.call(url)
+		end
+
 		title = self.title
 		a =  create_html_element 'img'
-			a.attributes['src'] = url.to_s
-			a.attributes['alt'] = children_to_s 
+		a.attributes['src'] = url.to_s
+		a.attributes['alt'] = children_to_s 
 		return a
 	end
 

data/lib/omf_web.rb

@@ -1,4 +1,5 @@
 
+require 'omf-web/version'
 
 module OMF
   module Web
@@ -6,11 +7,15 @@ module OMF
     module Rack; end
     module Widget; end
     
-    VERSION = 'git:release-5.4'
+    #VERSION = 'git:release-5.4'
     
     def self.start(opts, &block)
       require 'omf-web/thin/runner'
       
+      if layout = opts.delete(:layout)
+        load_widget_from_file(layout)
+      end
+      
       #Thin::Logging.debug = true
       runner = OMF::Web::Runner.new(ARGV, opts)
       block.call if block
@@ -30,7 +35,17 @@ module OMF
       wdescr = deep_symbolize_keys widget_descr
       OMF::Web::Widget.register_widget(wdescr)
     end
-    
+
+    def self.load_widget_from_file(file_name)
+      require 'yaml'
+      y = YAML.load_file(file_name)
+      if w = y['widget']
+        OMF::Web.register_widget w
+      else
+        OMF::Common::LObject.error "Doesn't seem to be a widget definition. Expected 'widget' but found '#{y.keys.join(', ')}'"
+      end
+    end
+  
     def self.use_tab(tab_id)
       OMF::Web::Tab.use_tab tab_id.to_sym          
     end

data/omf_web.gemspec

@@ -4,7 +4,6 @@ require "omf-web/version"
 
 Gem::Specification.new do |s|
   s.name        = "omf_web"
-#  s.version     = OmfWeb::VERSION
   s.version     = OMF::Web::VERSION
   s.authors     = ["NICTA"]
   s.email       = ["omf-user@lists.nicta.com.au"]

data/share/htdocs/graph/js/abstract_widget.js

@@ -146,7 +146,9 @@ L.provide('OML.abstract_widget', ["vendor/d3/d3.js"], function () {
     
     process_schema: function() {
       this.schema = this.process_single_schema(this.data_source);
-      this.mapping = this.process_single_mapping(null, this.opts.mapping, this.decl_properties);
+      if (typeof(this.decl_properties) != "undefined") {
+        this.mapping = this.process_single_mapping(null, this.opts.mapping, this.decl_properties);
+      }
     },
     
     process_single_schema: function(data_source) {

data/share/htdocs/graph/js/barchart_brush.js

@@ -0,0 +1,240 @@
+/*
+ * Draws a simple barchart wiht a slection brush.
+ * 
+ * Most code was copied from http://square.github.com/crossfilter/ and all that
+ * credit goes to Mike Bostok.
+ */
+
+
+L.provide('OML.barchart_brush', ["graph/js/abstract_chart", "#OML.abstract_chart"], function () {
+
+  OML.barchart_brush = OML.abstract_chart.extend({
+    decl_properties: [
+      ['key', 'int', {property: 'key'}], 
+      ['value', 'float', {property: 'value'}], 
+      // ['x_axis', 'key', {property: 'x'}], 
+      // ['y_axis', 'key', {property: 'y'}], 
+      // ['group_by', 'key', {property: 'id', optional: true}],             
+      ['stroke_width', 'int', 2], 
+      ['stroke_color', 'color', 'white'],
+      ['fill_color', 'color', 'blue']
+    ],
+    
+    defaults: function() {
+      return this.deep_defaults({
+        relative: false,   // If true, report percentage
+        axis: {
+          orientation: 'horizontal'
+        }
+      }, OML.barchart_brush.__super__.defaults.call(this));      
+    },
+    
+    configure_base_layer: function(vis) {
+      var base = this.base_layer = vis.append("svg:g")
+                                      .attr("class", "barchart")
+                                      ;
+      var ca = this.chart_area; 
+      this.legend_layer = base.append("svg:g");
+      this.chart_layer = base.append("svg:g");
+      this.axis_layer = base.append('g');
+    },
+    
+    redraw: function(data) {
+        
+    }    
+  }) // end of barchart_brush    
+
+
+
+  OML._barchart_brush = function barChart() {
+    if (!OML._barchart_brush.id) OML._barchart_brush.id = 0;
+
+    var margin = {top: 10, right: 10, bottom: 20, left: 10},
+        x,
+        y = d3.scale.linear().range([100, 0]),
+        id = OML._barchart_brush.id++,
+        axis = d3.svg.axis().orient("bottom"),
+        brush = d3.svg.brush(),
+        brushDirty,
+        dimension,
+        group,
+        round;
+
+    function chart(div) {
+      var width = x.range()[1],
+          height = y.range()[0];
+
+      y.domain([0, group.top(1)[0].value]);
+
+      div.each(function() {
+        var div = d3.select(this),
+            g = div.select("g");
+
+        // Create the skeletal chart.
+        if (g.empty()) {
+          div.select(".title").append("a")
+              .attr("href", "javascript:reset(" + id + ")")
+              .attr("class", "reset")
+              .text("reset")
+              .style("display", "none");
+
+          g = div.append("svg")
+              .attr("width", width + margin.left + margin.right)
+              .attr("height", height + margin.top + margin.bottom)
+            .append("g")
+              .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
+
+          g.append("clipPath")
+              .attr("id", "clip-" + id)
+            .append("rect")
+              .attr("width", width)
+              .attr("height", height);
+
+          g.selectAll(".bar")
+              .data(["background", "foreground"])
+            .enter().append("path")
+              .attr("class", function(d) { return d + " bar"; })
+              .datum(group.all());
+
+          g.selectAll(".foreground.bar")
+              .attr("clip-path", "url(#clip-" + id + ")");
+
+          g.append("g")
+              .attr("class", "axis")
+              .attr("transform", "translate(0," + height + ")")
+              .call(axis);
+
+          // Initialize the brush component with pretty resize handles.
+          var gBrush = g.append("g").attr("class", "brush").call(brush);
+          gBrush.selectAll("rect").attr("height", height);
+          gBrush.selectAll(".resize").append("path").attr("d", resizePath);
+        }
+
+        // Only redraw the brush if set externally.
+        if (brushDirty) {
+          brushDirty = false;
+          g.selectAll(".brush").call(brush);
+          div.select(".title a").style("display", brush.empty() ? "none" : null);
+          if (brush.empty()) {
+            g.selectAll("#clip-" + id + " rect")
+                .attr("x", 0)
+                .attr("width", width);
+          } else {
+            var extent = brush.extent();
+            g.selectAll("#clip-" + id + " rect")
+                .attr("x", x(extent[0]))
+                .attr("width", x(extent[1]) - x(extent[0]));
+          }
+        }
+
+        g.selectAll(".bar").attr("d", barPath);
+      });
+
+      function barPath(groups) {
+        var path = [],
+            i = -1,
+            n = groups.length,
+            d;
+        while (++i < n) {
+          d = groups[i];
+          path.push("M", x(d.key), ",", height, "V", y(d.value), "h9V", height);
+        }
+        return path.join("");
+      }
+
+      function resizePath(d) {
+        var e = +(d == "e"),
+            x = e ? 1 : -1,
+            y = height / 3;
+        return "M" + (.5 * x) + "," + y
+            + "A6,6 0 0 " + e + " " + (6.5 * x) + "," + (y + 6)
+            + "V" + (2 * y - 6)
+            + "A6,6 0 0 " + e + " " + (.5 * x) + "," + (2 * y)
+            + "Z"
+            + "M" + (2.5 * x) + "," + (y + 8)
+            + "V" + (2 * y - 8)
+            + "M" + (4.5 * x) + "," + (y + 8)
+            + "V" + (2 * y - 8);
+      }
+    }
+
+    brush.on("brushstart.chart", function() {
+      var div = d3.select(this.parentNode.parentNode.parentNode);
+      div.select(".title a").style("display", null);
+    });
+
+    brush.on("brush.chart", function() {
+      var g = d3.select(this.parentNode),
+          extent = brush.extent();
+      if (round) g.select(".brush")
+          .call(brush.extent(extent = extent.map(round)))
+        .selectAll(".resize")
+          .style("display", null);
+      g.select("#clip-" + id + " rect")
+          .attr("x", x(extent[0]))
+          .attr("width", x(extent[1]) - x(extent[0]));
+      dimension.filterRange(extent);
+    });
+
+    brush.on("brushend.chart", function() {
+      if (brush.empty()) {
+        var div = d3.select(this.parentNode.parentNode.parentNode);
+        div.select(".title a").style("display", "none");
+        div.select("#clip-" + id + " rect").attr("x", null).attr("width", "100%");
+        dimension.filterAll();
+      }
+    });
+
+    chart.margin = function(_) {
+      if (!arguments.length) return margin;
+      margin = _;
+      return chart;
+    };
+
+    chart.x = function(_) {
+      if (!arguments.length) return x;
+      x = _;
+      axis.scale(x);
+      brush.x(x);
+      return chart;
+    };
+
+    chart.y = function(_) {
+      if (!arguments.length) return y;
+      y = _;
+      return chart;
+    };
+
+    chart.dimension = function(_) {
+      if (!arguments.length) return dimension;
+      dimension = _;
+      return chart;
+    };
+
+    chart.filter = function(_) {
+      if (_) {
+        brush.extent(_);
+        dimension.filterRange(_);
+      } else {
+        brush.clear();
+        dimension.filterAll();
+      }
+      brushDirty = true;
+      return chart;
+    };
+
+    chart.group = function(_) {
+      if (!arguments.length) return group;
+      group = _;
+      return chart;
+    };
+
+    chart.round = function(_) {
+      if (!arguments.length) return round;
+      round = _;
+      return chart;
+    };
+
+    return d3.rebind(chart, brush, "on");
+  }
+});