flok 0.0.40 → 0.0.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc78ec824536368816557ea2429cc882fa3e6ad2
-  data.tar.gz: 80886a45fa70d64ab8d1d9d1806452636215a834
+  metadata.gz: d5f0a382decc21b5e55f99815a7b23ecf1f53009
+  data.tar.gz: b5f74e961712e188e97fc94da0b51fbac5e664b2
 SHA512:
-  metadata.gz: 0c42dd2f5b49bad2ce1dce1fb1b15f5ace5d20936d01df4f4efb5658c5338332c39a81363091cba50d5d2fb5d1a9a41c15c79198d9f87493e1c93c8b4d60331c
-  data.tar.gz: cc7ac536f24ce5f3b0501cc1523148c36bc916e4bb8694d1862b24d2ff5b955434c4bf63f24e1b82fc37cb10b5ab671d18e921c0271c268a4fb921b5fb5bfe0e
+  metadata.gz: 56c35e867d9766f03239f2ce0343fac6ba34f4af931b6b30e1b69ce3bd5c13e2d3dd8b9a11e9e6d16dbf87247a1757f68d7eedd26fe20da14297a558cd95394c
+  data.tar.gz: 48bb0f9c0b18b43582b0960bcd661f233fbe3d471025b41402a32dc32a343a40a23e108741f5fcb9b076e74555c572979828f88cdc1bf3f4cc8d23c254a6d68c

data/app/drivers/chrome/src/dispatch.js

@@ -63,10 +63,15 @@ function if_dispatch(qq) {
     }
   <% end %>
 
-
+  //If the array was marked incomplete, we need to grab
+  //more info so we send a blank array for a request
   if (if_dispatch_call_int_end) {
     if_dispatch_call_int_end = false;
-    int_dispatch([])
+
+    var call = function() {
+      int_dispatch([]);
+    };
+    setTimeout(call, 0);
   }
 }
 

data/app/kern/dispatch.js

@@ -9,6 +9,15 @@
 //Here is an example with two successive calls
 //  [2, 'mul', 3, 4, 1, 'print', 'hello world']
 function int_dispatch(q) {
+  //If there are things on the defer queue, then grab
+  //one of them for now and do it
+  if (edefer_q.length > 0) {
+    var ep = edefer_q.shift();
+    var ename = edefer_q.shift();
+    var info = edefer_q.shift();
+    int_event(ep, ename, info);
+  }
+
   //Where there is still things left on the queue
   while (q.length > 0) {
     //Grab the first thing off the queue, this is the arg count
@@ -96,7 +105,7 @@ function int_dispatch(q) {
     dump.push(out);
   }
 
-  if (incomplete) { dump.unshift("i"); }
+  if (incomplete || edefer_q.length > 0) { dump.unshift("i"); }
 
   if (dump.length != 0) {
     if_dispatch(dump);

data/app/kern/mod/event.js

@@ -1,6 +1,9 @@
 //Event handler table
 evt = {};
 
+//Event defer queue
+edefer_q = [];
+
 function int_event(ep, event_name, info) {
   var f = evt[ep];
   if (f != undefined) {
@@ -19,6 +22,12 @@ function dereg_evt(ep) {
   delete evt[ep];
 }
 
+function int_event_defer(ep, ename, info) {
+  edefer_q.push(ep);
+  edefer_q.push(ename);
+  edefer_q.push(info);
+}
+
 //Spec helpers
 ////////////////////////////////////////////////////////////////
 function spec_event_handler(ep, event_name, info) {

data/app/kern/pagers/pg_mem.js

@@ -0,0 +1,21 @@
+//Configure pg_mem0, pg_mem1, pg_mem2
+<% [0, 1, 2].each do |i| %>
+  function pg_mem<%= i %>_init(ns, options) {
+    pg_mem<%= i %>_init_params = {ns: ns, options: options};
+    pg_mem<%= i %>_ns = ns;
+
+    <% if @debug %>
+      pg_mem<%= i %>_spec_did_init = true;
+    <% end %>
+  }
+
+  function pg_mem<%= i %>_watch(id, page) {
+  }
+
+  function pg_mem<%= i %>_unwatch(id) {
+  }
+
+  function pg_mem<%= i %>_write(page) {
+    vm_cache_write(pg_mem<%= i %>_ns, page);
+  }
+<% end %>

data/app/kern/pagers/pg_net_sim.js

@@ -0,0 +1,44 @@
+<% if @debug %>
+function pg_net_sim_init(ns, options) {
+  pg_net_sim_spec_did_init = true;
+  pg_net_sim_ns = ns;
+
+  //Set timer to tick every 2 seconds
+  reg_evt(-9393, pg_net_sim_tick_handler);
+  reg_interval(-9393, "tick", 4*2);
+
+  pg_net_sim_waiting_for_response = [];
+}
+
+function pg_net_sim_tick_handler(ep, ename, info) {
+  while (pg_net_sim_waiting_for_response.length > 0) {
+    var e = pg_net_sim_waiting_for_response.shift();
+    vm_cache_write(pg_net_sim_ns, pg_net_sim_stored_pages[e.id]);
+  }
+}
+
+function pg_net_sim_watch(id, page) {
+  if (pg_net_sim_stored_pages[id] === undefined) {
+    throw "Could not get page with id: " + id;
+  }
+
+  pg_net_sim_waiting_for_response.push({id: id});
+}
+
+function pg_net_sim_unwatch(id) {
+}
+
+function pg_net_sim_write(page) {
+  vm_cache_write(pg_net_sim_ns, page);
+}
+
+//Special support function to simulate pages stored
+//on a server
+pg_net_sim_stored_pages = {};
+function pg_net_sim_load_pages(pages) {
+  for (var i = 0; i < pages.length; ++i) {
+    var page = pages[i];
+    pg_net_sim_stored_pages[page._id] = page;
+  }
+}
+<% end %>

data/app/kern/pagers/pg_spec.js

@@ -0,0 +1,23 @@
+//Configure pg_spec0 and pg_spec1
+<% if @debug %>
+  <% [0, 1].each do |i| %>
+    function pg_spec<%= i %>_init(ns, options) {
+      pg_spec<%= i %>_watchlist = [];
+      pg_spec<%= i %>_unwatchlist = [];
+      pg_spec<%= i %>_init_params = {ns: ns, options: options};
+      pg_spec<%= i %>_ns = ns;
+    }
+
+    function pg_spec<%= i %>_watch(id, page) {
+      pg_spec<%= i %>_watchlist.push({id: id, page: page});
+    }
+
+    function pg_spec<%= i %>_unwatch(id) {
+      pg_spec<%= i %>_unwatchlist.push(id);
+    }
+
+    function pg_spec<%= i %>_write(page) {
+      vm_cache_write(pg_spec<%= i %>_ns, page);
+    }
+  <% end %>
+<% end %>

data/app/kern/services/vm.rb

@@ -16,7 +16,11 @@ service :vm do
     vm_bp_to_nmap = {};
 
     //Notification listeners, converts ns+key to an array of base pointers
-    vm_notify_map = {};
+    vm_notify_map = {
+      <% @options[:pagers].each do |p| %>
+        <%= p[:namespace] %>: {},
+      <% end %>
+    };
 
     //Cache
     function vm_cache_write(ns, page) {
@@ -26,14 +30,11 @@ service :vm do
       vm_dirty[ns][page._id] = page;
       vm_cache[ns][page._id] = page;
 
-      var a = vm_notify_map[ns];
-      if (a) {
-        var b = a[page._id];
-
-        if (b) {
-          for (var i = 0; i < b.length; ++i) {
-            int_event(b, "read_res", page);
-          }
+      //Try to lookup view controller(s) to notify
+      var nbp = vm_notify_map[ns][page._id];
+      if (nbp) {
+        for (var i = 0; i < nbp.length; ++i) {
+          int_event_defer(nbp[i], "read_res", page);
         }
       }
     }
@@ -47,11 +48,27 @@ service :vm do
 
       z = crc32(z, page._id)
 
-      var e = page.entries;
-      for (var i = 0; i < e.length; ++i) {
-        z = crc32(z, e[i]._sig);
+      //Hash differently based on type
+      if (page._type === "array") {
+        var e = page.entries;
+        for (var i = 0; i < e.length; ++i) {
+          z = crc32(z, e[i]._sig);
+        }
+      } else if (page._type === "hash") {
+        var keys = Object.keys(page.entries);
+        var e = page.entries;
+        var q = 0;
+        for (var i = 0; i < keys.length; ++i) {
+          var _sig = e[keys[i]]._sig;
+          var r = crc32(0, _sig);
+          q = q + r;
+        }
+        q = +q;
+        z = crc32(z, q.toString());
+      } <% if @debug %> else {
+        throw "vm_rehash_page got an unspported type: "+page._type;
       }
-
+      <% end %>
       page._hash = z.toString();
     }
 
@@ -67,10 +84,9 @@ service :vm do
             var p = id_to_page[ids[i]];
             SEND("disk", "if_per_set", "<%= p[:namespace] %>", ids[i], p);
           }
-        <% end %>
         }
+        <% end %>
 
-      //Clear dirty list
       vm_dirty = {
         <% @options[:pagers].each do |p| %>
           <%= p[:namespace] %>: {},
@@ -81,6 +97,9 @@ service :vm do
     //Part of the persist module
     //res is page
     function int_per_get_res(s, ns, res) {
+      //If the key didn't exist, ignore it
+      if (res === null) { return; }
+
       //If there is already a cached entry, a pager beat us to it
       //ignore this for now because the pager should be more up to
       //date
@@ -112,6 +131,7 @@ service :vm do
   }
 
   on_connect %{
+    vm_bp_to_nmap[bp] = {};
   }
 
   on_disconnect %{
@@ -146,25 +166,6 @@ service :vm do
     delete vm_bp_to_nmap[bp];
   }
 
-  on "read_sync", %{
-    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
-
-    var cres = vm_cache[params.ns][params.key]; 
-    if (cres != undefined) {
-      int_event(bp, "read_res", {key: params.key, value: cres});
-      return;
-    }
-
-    <% @options[:pagers].each do |p| %>
-      if (params.ns === "<%= p[:namespace] %>") {
-        var res = <%= p[:name] %>_read_sync(params.ns, bp, params.key);
-      }
-    <% end %>
-    vm_read_sync_called = true;
-
-    int_event(bp, "read_sync_res", res);
-  }
-
   on "write", %{
     <% raise "No pagers given in options for vm" unless @options[:pagers] %>
 
@@ -190,31 +191,24 @@ service :vm do
 
     //Ensure map exists
     ////////////////////////////////////////////////
-    var a = vm_notify_map[params.ns];
-    if (!a) {
-      a = {};
-      vm_notify_map[params.ns] = a;
-    }
-
-    var b = a[params.id];
+    var b = vm_notify_map[params.ns][params.id];
     if (!b) {
       b = [];
-      a[params.id] = b;
+      vm_notify_map[params.ns][params.id] = b;
+    }
+
+    //Check if it exists, if it's already being watched, ignore it
+    var midx = vm_notify_map[params.ns][params.id].indexOf(bp)
+    if (midx != -1) {
+      return;
     }
 
-    <% if @debug %>
-      var midx = vm_notify_map[params.ns][params.id].indexOf(bp)
-      if (midx != -1) {
-        throw "Multiple calls to watch for the ns: " +  params.ns + " and id: " + params.id
-      }
-    <% end %>
     b.push(bp)
     ////////////////////////////////////////////////
 
     //Add to vm_bp_to_nmap
     ////////////////////////////////////////////////
     //Construct 
-    if (vm_bp_to_nmap[bp] === undefined) { vm_bp_to_nmap[bp] = {}; }
     if (vm_bp_to_nmap[bp][params.ns] === undefined) { vm_bp_to_nmap[bp][params.ns] = {}; }
 
     //Add reverse mapping, length-1 because it was just pushed
@@ -222,7 +216,12 @@ service :vm do
 
     //If cache exists, then signal controller *now* while we wait for the pager
     if (cache_entry) {
-      int_event(bp, "read_res", cache_entry);
+      //If sync flag is set, then send the data *now*
+      if (params.sync) {
+        int_event(bp, "read_res", cache_entry);
+      } else {
+        int_event_defer(bp, "read_res", cache_entry);
+      }
     }
 
     //Send a request now for disk read for sync
@@ -251,25 +250,22 @@ service :vm do
     <% end %>
   }
 
-  on "unwatch", %{
-    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
-
-    var midx = vm_notify_map[params.ns][params.id].indexOf(bp)
-    vm_notify_map[params.ns][params.id].splice(midx, 1);
-
-    delete vm_bp_to_nmap[bp][params.ns][params.id];
-
-    <% @options[:pagers].each do |p| %>
-      if (params.ns === "<%= p[:namespace] %>") {
-        <%= p[:name] %>_unwatch(params.id);
-      }
-    <% end %>
-  }
 
   on "unwatch", %{
     <% raise "No pagers given in options for vm" unless @options[:pagers] %>
 
+    //It won't have an array if it was never watched
+    if (vm_notify_map[params.ns][params.id] === undefined) {
+      return;
+    }
+
+    //Get the position of bp in the watch array, this may not exist, in which case
+    //this controller is not actually watching it.
     var midx = vm_notify_map[params.ns][params.id].indexOf(bp)
+    if (midx === -1) {
+      return;
+    }
+
     vm_notify_map[params.ns][params.id].splice(midx, 1);
 
     delete vm_bp_to_nmap[bp][params.ns][params.id];

data/bin/flok

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'flok'
+require_relative '../lib/flok'
 require 'thor'
 require 'fileutils'
 require 'webrick'
@@ -45,7 +45,8 @@ class FlokCLI < Thor
 
     #3. Build the client's ./app/controllers/*.rb into './products/$PLATFORM/user_compiler.js'
     controller_glob_path = "#{local_products_path}/#{platform}/glob/controllers.rb" 
-    Flok.src_glob("rb", './app/controllers', controller_glob_path)
+    Flok.src_glob_r("rb", './app/controllers', controller_glob_path)
+
     user_compiler_js = Flok::UserCompiler.compile File.read(controller_glob_path)
     services_config_js = File.read "./config/services.rb"
     Flok.src_glob("rb", './app/services', File.join(local_products_path, platform, "./services/user_services.rb"))
@@ -95,29 +96,49 @@ class FlokCLI < Thor
     #Ensure puts does something because it's on another thread
     $stdout.sync = true
 
-    ###########################################################################
-    #We execute two tasks that run at the same time, (1) the webrick hoster
-    #and (2) the guard reloader that triggers build
-    ###########################################################################
-    #1) Launch webrick server
-    server = WEBrick::HTTPServer.new :Port => 9992, :DocumentRoot => "./products/#{platform}", :StartCallback => Proc.new {
-    }
-    server_started = false
-
-    #2) Wait for initial build to launch (all_on_start)
-    sh2("guard") do |inp, out|
-      loop do
-        res = out.readline
-        if res =~ /BUILD RAN/
-          #Start server
-          Thread.new { server.start } unless server_started
-          server_started = true
-
-          puts "BUILD RAN"
-        else
-          $stderr.puts res
+    begin
+      @pid = fork do
+        server = WEBrick::HTTPServer.new :Port => 9992, :DocumentRoot => ".", :StartCallback => Proc.new {
+          puts "SERVER STARTED"
+        }
+
+        @build_q = Queue.new
+        @build_q.push 0
+        server.mount_proc "/" do |req, res|
+          #Semaphore for build; multiple requests execute 1 build
+          unless @build_q.empty?
+            @build_q.pop
+
+            _res = system("#{__FILE__} build")
+
+            @build_q.push 0
+          else
+            @build_q.pop
+            @build_q.push 0
+            _res = true
+          end
+
+          $stderr.puts "res = #{_res}"
+
+          #/products/application_user.js, etc. local path with dot
+          path = "./products/#{platform}/#{req.path}"
+          if _res == true
+            res.body = File.read(path)
+          else
+            res.body = ""
+          end
+          res.header["Access-Control-Allow-Origin"] = "*"
+          #res.header["Content-Type"] = "json/text"
         end
+
+        server.start
+      end
+
+      loop do
+        sleep 1
       end
+    ensure
+      Process.kill :KILL, @pid
     end
   end