flok 0.0.79 → 0.0.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aca1d7de35bb76f6ca3adf9142e6ba509161a5de
-  data.tar.gz: 07984726091817ae868f9a864ad38108510f26e5
+  metadata.gz: 0211bf5635601e2e799ddd564e3612c8a02e1354
+  data.tar.gz: 45aa0d364ed30d8a2d01e0ca2d4cb2abcd2ab61b
 SHA512:
-  metadata.gz: 5eec59b970ba96dda10d87394323839c35ed7dba250be6c250d03c289c4e1ee7f0a2f909cd09c9da1c2137d2d6da8cfbd1e4c1d8ff4afa4d18f1a00ba9541252
-  data.tar.gz: 57f42e576fe8cb437f5d01df8e07dda29df8093d248abb90d3aedfaa7284b52904a9881f6feb47903720df2a247f7e75610fdbfd6908dc496d3186dea7f910a4
+  metadata.gz: f47cfbb76f1f5aa170fb8c38963c9df5a2d0179ef617d90c4f7981b733097cf26e6cc4c26c9a74881c1806c40a73a6935d0063ca489c7102630e767e63f59cdd
+  data.tar.gz: 2ab9e84d9daeccf7f11877a4443e8f36a4fcd3ede44cf0cc0ee7ee5a3413c946e9b20d694ee36c131633d8a3c568cc720d798064ca2a4817c441c44f0cb03d63

data/app/kern/pagers/pg_spec.js

@@ -6,6 +6,7 @@
       pg_spec<%= i %>_unwatchlist = [];
       pg_spec<%= i %>_init_params = {ns: ns, options: options};
       pg_spec<%= i %>_ns = ns;
+      pg_spec<%= i %>_sync_requests = [];
     }
 
     function pg_spec<%= i %>_watch(id, page) {
@@ -21,5 +22,9 @@
       vm_cache_write(pg_spec<%= i %>_ns, page);
       vm_transaction_end();
     }
+
+    function pg_spec<%= i %>_sync(page_id) {
+      pg_spec<%= i %>_sync_requests.push(page_id);
+    }
   <% end %>
 <% end %>

data/app/kern/services/vm.rb

@@ -1,5 +1,7 @@
 service :vm do
   global %{
+    //Some of the shared datatypes
+    ////////////////////////////////////////////////////////////////////////////////////////////
     //Cache contains a blank hash for each namespace
     vm_cache = {
       <% @options[:pagers].each do |p| %>
@@ -13,8 +15,6 @@ service :vm do
       <% end %>
     };
 
-    //See 'Datatypes & Structures' in ./docs/services/vm.md  
-    ////////////////////////////////////////////////////////////////////////////////////////////
     vm_bp_to_nmap = {};
     vm_pager_waiting_read = {
       <% @options[:pagers].each do |p| %>
@@ -29,6 +29,7 @@ service :vm do
         <%= p[:namespace] %>: {},
       <% end %>
     };
+
     ////////////////////////////////////////////////////////////////////////////////////////////
 
     //Cache
@@ -505,6 +506,58 @@ service :vm do
       }
     }
     ///////////////////////////////////////////////////////////////////////////
+
+    //vm unsynced
+    ///////////////////////////////////////////////////////////////////////////
+    //Unsynced page ids to integer vm_unsynced[bp][page_id] = '0' or '1'
+    //where 0 is freshly added and ignored on the first pass of the daemon
+    vm_unsynced = {
+      <% @options[:pagers].each do |p| %>
+        <%= p[:namespace] %>: {},
+      <% end %>
+    };
+
+    function vm_pg_mark_needs_sync(ns, page_id) {
+      //Add to list
+      vm_unsynced[ns][page_id] = 0;
+
+      //Notify pager immediately (daemon will not notify pager on first tick to avoid calling pager's sync to soon)
+      <% @options[:pagers].each do |p| %>
+        <% @options[:pagers].each_with_index do |p, i| %>
+          <% if i == 0 %>
+            if ("<%= p[:namespace] %>" === ns) {
+              <%= p[:name] %>_sync(page_id);
+            }
+          <% else %>
+            else if ("<%= p[:namespace] %>" === ns) {
+              <%= p[:name] %>_sync(page_id);
+            }
+          <% end %>
+        <% end %>
+      <% end %>
+    }
+
+    function vm_pg_unmark_needs_sync(ns, page_id) {
+      delete vm_unsynced[ns][page_id];
+    }
+
+    function vm_pg_sync_wakeup() {
+      //Iterate through all the unsynced entries an increment any entries that are 0 to 1
+      <% @options[:pagers].each do |p| %>
+        //Get all page ids in a namespace
+        var page_ids = Object.keys(vm_unsynced.<%= p[:namespace] %>);
+
+        for (var i = 0; i < page_ids.length; ++i) {
+          if (vm_unsynced.<%= p[:namespace] %>[page_ids[i]] === 0) {
+            vm_unsynced.<%= p[:namespace] %>[page_ids[i]] = 1;
+          } else {
+            //Notify pager
+            <%= p[:name] %>_sync(page_ids[i]);
+          }
+        }
+      <% end %>
+    }
+    ///////////////////////////////////////////////////////////////////////////
   }
 
   on_wakeup %{
@@ -711,5 +764,6 @@ service :vm do
 
   every 20.seconds, %{
     vm_pageout();
+    vm_pg_sync_wakeup();
   }
 end

data/docs/services/vm.md

@@ -143,11 +143,23 @@ requested. This is because a cached page will be returned by the call stack whil
 ##Cache
 See below with `vm_cache_write` for how to write to the cache. Each pager can choose whether or not to cache; some pagers may cache only reads while others will cache writes.  Failure to write to the cache at all will cause `watch` to never trigger. Some pagers may use a trick where writes are allowed, and go directly to the cache but nowhere else. This is to allow things like *pending* transactions where you can locally fake data until a server response is received which will both wipe the fake write and insert the new one. Cache writes will trigger `watch`; if you write to cache with `vm_cache_write` with a page that has the same `_hash` as a page that already exists in cache, no `watch` events will be triggered. Additionally, calling `vm_cache_write` with a non-modified page will result in no performance penalty. `vm_cache_write` notifies controllers asynchronously and is not effected by the `watch` flag on controllers.
 
-###Pageout & Cache Synchronization
-Cache will periodically be synchronized to disk via the `pageout` service. When flok reloads itself, and the `vm` service gets a `watch` or `watch_sync` request, the `vm` service will attempt to read from the `vm_cache` first and then read the page from disk (write that disk read to cache). The only difference between `watch_sync` and `watch` is that `watch_sync` will synchronously pull from disk and panic if there is no cache available for the page). (Both `watch` and `watch_sync` will always call the pager's after the cache read as well.)
+###Pageout, Cache Synchronization, and Pager Synchronization
+####Pageout Daemon
+Cache will periodically be synchronized to disk via the `pageout` service. When flok reloads itself, and the `vm` service gets a `watch` the `vm` service will attempt to read from the `vm_cache` first and then read the page from disk (write that disk read to cache).
 
 Pageout is embodied in the function named `vm_pageout()`. This will asynchronously write `vm_dirty` to disk and clear `vm_dirty` once the write has been commited. `vm_pageout()` is called every minute by the interval timer in this service.
 
+####Pager Synchronization Daemon
+When pagers get a write request, many pagers (as in all of them atm) mark the pages via `vm_pg_mark_needs_sync` which first calls the pagers `sync`
+routine immediately and writes to the `vm_unsynced` hash. The hash is used like `vm_unsynced[ns][page_id]` which yields an integer value. The integer
+value is either `0` or `1`. When `vm_pg_mark_needs_sync` is first called, the value is set to `0`. When the pager synchronization daemon
+goes over the list in `vm_unsynced`; the daemon checks the integer field. If the integer is `0`, then the daemon only increments the integer. If the
+integer is `1`, then the daemon notifies the pager with the `sync` action. The reason this is done is to avoid calling a pagers `sync` function too
+soon as it is immediately called the first time when the pager calls `vm_pg_mark_needs_sync` on the page (usually at the end of the `write` action
+for the pager). The pager de-registers the page via `vm_pg_unmark_needs_sync`.
+
+The pager synchronization daemon is embodied in the function called `vm_pg_sync_wakeup`
+
 ###Datatypes & Structures (Opaque, do not directly modify)
   * `vm_cache` - The main area for storing the cache. Stored in `vm_cache[ns][key]`. Contains all namespaces by default with blank hashes.
   * `vm_dirty` - Pages recently written to cache go on the dirty list so that they may be written when the pageout handler runs. Dictionary contains map for `vm_dirty[ns][page._id] => page` for all dirty pages. Pages are removed from the dictionary when they are written in the pageout. Contains all namespaces by default with blank hashes.
@@ -159,6 +171,11 @@ Pageout is embodied in the function named `vm_pageout()`. This will asynchronous
       during a sync call for disk reads or the synchronous `read_sync` request. The format for each element in the array is `{"page_id": [bp1, bp2], ...}`
   * `vm_pager_waiting_read` - A hash that maps `[ns][page_id]` into a hash that represents a the page that was trying to be written.
       needed to be read before notifying the pager. Multiple write attempts on the same page before the disk response will undefined behavior.
+  * `vm_unsynced_*`
+    * `vm_unsynced` - A hash that maps `vm_unsynced_fresh[ns][page_id]` to an integer that is either `0` or `1`. the vm sync daemon reads over this
+        queue and `0` means that it was just requested via `vm_pg_mark_needs_sync` and needs to be incremented to `1`. `1` means that the vm sync
+        daemon must contact the pager for the `sync` action. This will happend until the pager calls `vm_pg_unmark_needs_sync` which will remove it
+        from this hash
 
 ##Helper Methods
 
@@ -196,9 +213,14 @@ Pageout is embodied in the function named `vm_pageout()`. This will asynchronous
         `__changes_id` of the page matches `changes_id`. If the page is based (implying the base page has changes and the page has changes as all base
         pages have changes), then if the `changes_id` matches the **base** `__changes_id` , the `__base` is removed from the page. If `changes_id`
         does not match in either of the cases, then nothing happends. This may happend if a synchronization errousouly comes in.
-###Non functional
+###Non functional (functional as is in lambda calculus, or lisp (no **global** state changes but may modify parameters)
 ####Pager specific
   * `vm_cache_write(ns,  page)` - Save a page to cache memory. This will not recalculate the page hash. The page will be stored in `vm_cache[ns][id]` by.
+  * `vm_pg_mark_needs_sync(ns, page_id)` - Marks that a page **in memory** is needing to be synced to the pager. This does a few things:
+    * The page_id is added to the `vm_unsynced` with the value of 0; see above in `Datatypes & Structures` for details. i.e.
+        `vm_unsynced[$PAGER_NS][page_id] = 0`
+    *  the pager's routine of `sync` is called immediately. The page must exist in cache at this point.
+  * `vm_pg_unmark_needs_sync(ns, page_id)` - Removes the page from the pending synchronization queue `delete vm_unsynced[$PAGER_NS][page_id]`)
 
 ### <a name='user_page_modification_helpers'></a>User page modification helpers (Controller Macros)
 You should never directly edit a page in user land; if you do; the pager has no way of knowing that you made modifications. Additionally, if you have multiple controllers watching a page, and it is modified in one controller, those other controllers

data/docs/services/vm/pagers.md

@@ -11,6 +11,9 @@ If you haven't already, read [VM Service](../vm.md) for context on pagers.
   * `$NAME_unwatch(id)` - There are no controllers that are watching the page with a page that contains this in the `_id` field
   * `$NAME_write(page)` - You should write this page, e.g. to network, and/or write to `vm_cache_write`.  Alternatively, you can write the page over the network and then let the response from that call `vm_cache_write` in what ever listening code you have.
     * `page` - A fully constructed page with correctly calculated `_hash` and _sigs on entries.
+  * `$NAME_sync(page_id)` - A page is requested to be synchronized. This was requested by the pager itself by `vm_pg_mark_needs_sync`.  Usually,
+      in `write`, a pager will call `vm_pg_mark_needs_sync` which will then invoke `$NAME_sync(page_id)` immediately and on a scheduled interval
+      via the synchronization vm daemon until this pager removes the page from the unsynchronized queues via `vm_pg_unmark_needs_sync`.
 
 ##When are pagers invoked?
 Pagers handle all requests from controllers except for the following conditions:
@@ -28,10 +31,11 @@ The *default memory pager* does not do anything on `watch` or `unwatch`. It depe
 
 ####Spec pager | `pg_spec0`, `pg_spec1`
 This pager does the following when calls are made to it's functions, it's designed to assist with `vm` kernel specs.
-  * `init` - Sets `pg_spec0_init_params` to `{ns: ns, options: options}`
-  * `watch` - Appends `{id: id, hash: hash}` to `pg_spec0_watchlist`
-  * `unwatch` - appends id to `pg_spec0_unwatchlist`
+  * `init` - Sets `pg_specN_init_params` to `{ns: ns, options: options}`
+  * `watch` - Appends `{id: id, hash: hash}` to `pg_specN_watchlist`
+  * `unwatch` - appends id to `pg_specN_unwatchlist`
   * `write` - Writes the given page to `vm_cache_write`
+  * `sync` - Appends given page_id to `pg_specN_sync_requests`
 
 These pagers only exists if the environment is in `DEBUG` mode (`@debug` is enabled).
 

data/docs/todo.md

@@ -0,0 +1,16 @@
+#Todo
+
+###Known issues & Bugs
+
+  0. A `every` event used in a controller's action will time correctly on the first action, but subsequent actions will be off by at most 3 ticks.
+  This is because we do not have any way (currently) to reset the timing queue in the controller as it reisters for all timing events at init. See
+  "Does not call intervals of other actions; and still works when switching back actions" in `spec/kern/controller_spec.rb` 
+  1. `vm_cache_write_sync_pending` in the `vm` service relies on page_ids, but this would cause a collision on two pages named the same thing. This
+   needs to integrate the namespace.
+  2. The pager synchronization daemon and functions associated with marking paging as needing synchronization will attempt to sync at one time and not
+  store the data if there is a crash or exit before synchronization completes. Furethermore, too many unsynced pages will wreck havok as they wil be
+  dispatched at the same time via the synchronization daemon.
+
+###Ideas for improvement
+  0. The `Raise` function should not actually signal the controller, it could just inline that
+  1. The controller's `ctable` could be flattened.

data/lib/flok/user_compiler.rb

@@ -494,7 +494,7 @@ module Flok
   end
 
   class UserCompilerAction
-    attr_accessor :controller, :name, :ons, :every_handlers, :on_entry_has_goto
+    attr_accessor :controller, :name, :ons, :every_handlers
     include UserCompilerMacro
 
     def initialize controller, name, ctx, &block
@@ -504,7 +504,6 @@ module Flok
       @_on_entry_src = ""
       @ons = [] #Event handlers
       @every_handlers = []
-      @on_entry_has_goto = false
 
       self.instance_eval(&block)
     end
@@ -512,8 +511,6 @@ module Flok
     def on_entry js_src
       #returns a string
       @_on_entry_src = _macro(js_src)
-
-      @on_entry_has_goto = (js_src =~ /Goto/) != nil
     end
 
     def on_entry_src
@@ -585,8 +582,6 @@ module Flok
 
     def choose_action &block
       @ctx.action self, :choose_action, &block
-
-      raise "choose_action must contain Goto" unless @ctx.actions.detect{|e| e.name == :choose_action}.on_entry_has_goto
     end
 
     #Names of spots

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.79"
+  VERSION = "0.0.80"
 end

data/spec/kern/assets/vm/config3.rb

@@ -2,7 +2,7 @@
 service_instance :vm, :vm, {
   :pagers => [
     {
-      :name => "spec2",
+      :name => "pg_spec0",
       :namespace => "user",
       :options => {
         "hello" => "world"

data/spec/kern/assets/vm/config5c.rb

@@ -0,0 +1,12 @@
+#Simple service config that uses built-in spec service to create a instance called 'spec'
+service_instance :vm, :vm, {
+  :pagers => [
+    {
+      :name => "pg_spec0",
+      :namespace => "spec",
+      :options => {
+        "hello" => "world"
+      }
+    }
+  ]
+}

data/spec/kern/assets/vm/controller10.rb

@@ -3,14 +3,7 @@ controller :my_controller do
 
   action :my_action do
     on_entry %{
-      var entry = {
-        hello: "world"
-      }
-
-      page = NewPage("array", "test");
-      SetPageHead(page, "head");
-      SetPageNext(page, "next");
-      EntryInsert(page, 0, entry);
+      var page = vm_create_page("test");
 
       var info = {
         ns: "spec",

data/spec/kern/assets/vm/controller11.rb

@@ -3,14 +3,7 @@ controller :my_controller do
 
   action :my_action do
     on_entry %{
-      var entry = {
-        hello: "world"
-      }
-
-      page = NewPage("array", "test");
-      SetPageHead(page, "head");
-      SetPageNext(page, "next");
-      EntryInsert(page, 0, entry);
+      var page = vm_create_page("test");
 
       var watch_info = {
         ns: "spec",

data/spec/kern/controller_spec.rb

@@ -979,18 +979,6 @@ RSpec.describe "kern:controller_spec" do
     @driver.mexpect("if_event", [Integer, "action", {"from" => nil, "to" => "index"}])
   end
 
-  it "Not setting a Goto will result in an exception" do
-    expect {
-      ctx = flok_new_user File.read('./spec/kern/assets/choose_action_sync_no_goto.rb'), File.read("./spec/kern/assets/test_service/config0.rb") 
-      ctx.evald %{
-        base = _embed("my_controller", 0, {}, null);
-
-        //Drain queue
-        int_dispatch([]);
-      }
-    }.to raise_exception
-  end
-
   it "Does support using a macro that contains current_action" do
     ctx = flok_new_user File.read('./spec/kern/assets/current_action_nav.rb')
     dump = ctx.evald %{

data/spec/kern/vm_service_spec.rb

@@ -39,21 +39,12 @@ RSpec.describe "kern:vm_service" do
 
     #Run the check
     res = ctx.eval %{
-      //Manually construct a page
-      page = {
-        _head: "a",
-        _next: "b",
-        _type: "array",
-        _id: "hello",
-        entries: [
-          {_id: "hello2", _sig: "nohteunth"},
-        ]
-      }
-
-      vm_rehash_page(page);
+      var page = vm_create_page("test");
 
       //Save page
+      vm_transaction_begin();
       vm_cache_write("user", page);
+      vm_transaction_end();
     }
 
     vm_cache = JSON.parse(ctx.eval("JSON.stringify(vm_cache)"))
@@ -114,20 +105,12 @@ RSpec.describe "kern:vm_service" do
       //which receives a call to watch with the hash of this page so the 
       //watch function can tell if the page has changed (e.g. if you are connecting)
       //to a remote server
-      page = {
-        _head: "a",
-        _next: "b",
-        _id: "my_key",
-        _type: "array",
-        entries: [
-          {_id: "hello2", _sig: "nohteunth"},
-        ]
-      }
-
-      vm_rehash_page(page);
+      var page = vm_create_page("test");
 
       //Save page for the spec pager
+      vm_transaction_begin();
       vm_cache_write("spec", page);
+      vm_transaction_end();
     }
 
     #This hash was calculated during vm_rehash_page
@@ -144,10 +127,7 @@ RSpec.describe "kern:vm_service" do
     pg_spec0_watchlist = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_watchlist)"))
 
     #Expect options and ns to match in config4
-    expect(pg_spec0_watchlist).to eq([{
-      "id" => "my_key",
-      "page" => page
-    }])
+    expect(pg_spec0_watchlist[0]["id"]).to eq("my_key")
   end
 
   it "does not throw an exception if multiple watches are attempted" do
@@ -351,6 +331,8 @@ RSpec.describe "kern:vm_service" do
       int_dispatch([]);
     }
 
+    @driver.int "int_per_get_res", ["vm", "spec", "test", nil]
+
     #Expect the page to be written to cache
     vm_cache = JSON.parse(ctx.eval("JSON.stringify(vm_cache)"));
     vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list[0])"));
@@ -367,8 +349,17 @@ RSpec.describe "kern:vm_service" do
       int_dispatch([]);
     }
 
-    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    #Write will attempt to read disk first
+    @driver.int "int_per_get_res", ["vm", "spec", "test", nil]
+
+    #Read is asynchronous
+    ctx.eval %{
+      //Drain queue
+      int_dispatch([]);
+    }
+
     vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list[0])"));
+    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
     expect(read_res_params).to eq(vm_write_list)
   end
 

data/spec/kern/vm_service_unsynced_spec.rb

@@ -0,0 +1,137 @@
+#The vm service
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+require 'zlib'
+
+RSpec.describe "kern:vm_service" do
+  include Zlib
+  include_context "kern"
+
+  it "vm_pg_mark_needs_sync does call the pagers sync routine and adds an entry in the vm_unsynced table with a value of 0" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config5c.rb") 
+    dump = ctx.evald %{
+      //Needed to initialize pagers
+      base = _embed("my_controller", 0, {}, null);
+
+      vm_pg_mark_needs_sync("spec", "test");
+
+      dump.vm_unsynced = vm_unsynced;
+      dump.pg_spec0_sync_requests = pg_spec0_sync_requests;
+    }
+
+    expect(dump["vm_unsynced"]).to eq({
+      "spec" => {
+        "test" => 0
+      }
+    })
+
+    expect(dump["pg_spec0_sync_requests"]).to eq(["test"])
+  end
+
+  it "vm_pg_unmark_needs_sync does remove the entry from the vm_unsynced table and does not fail if the entry does not exist" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config5c.rb") 
+    dump = ctx.evald %{
+      //Needed to initialize pagers
+      base = _embed("my_controller", 0, {}, null);
+
+      vm_pg_mark_needs_sync("spec", "test");
+      vm_pg_unmark_needs_sync("spec", "test");
+      vm_pg_unmark_needs_sync("spec", "test_non_existant_key");
+
+      dump.vm_unsynced = vm_unsynced;
+    }
+
+    expect(dump["vm_unsynced"]).to eq({
+      "spec" => {
+      }
+    })
+  end
+
+  #Don't sync when it's 0 because the pager just added it and we don't want to sync to early. Wait til next pass
+  it "vm_pg_sync_wakeup does increment any entries that are currently 0 to the value of 1 and does not invoke pager's sync for those entries" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config5c.rb") 
+    dump = ctx.evald %{
+      //Needed to initialize pagers
+      base = _embed("my_controller", 0, {}, null);
+
+      vm_pg_mark_needs_sync("spec", "test");
+      vm_pg_sync_wakeup();
+
+      dump.vm_unsynced = vm_unsynced;
+      dump.pg_spec0_sync_requests = pg_spec0_sync_requests;
+    }
+
+    expect(dump["vm_unsynced"]).to eq({
+      "spec" => {
+        "test" => 1
+      }
+    })
+
+    #Only expect one entry, wakeup should have skipped the first try
+    expect(dump["pg_spec0_sync_requests"]).to eq(["test"])
+  end
+
+  it "vm_pg_sync_wakeup does *not* increment any entries that are currently 1 and *does* invoke pager's sync for those entries" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config5c.rb") 
+    dump = ctx.evald %{
+      //Needed to initialize pagers
+      base = _embed("my_controller", 0, {}, null);
+
+      vm_pg_mark_needs_sync("spec", "test");
+      vm_pg_sync_wakeup();
+      vm_pg_sync_wakeup();
+
+      dump.vm_unsynced = vm_unsynced;
+      dump.pg_spec0_sync_requests = pg_spec0_sync_requests;
+    }
+
+    expect(dump["vm_unsynced"]).to eq({
+      "spec" => {
+        "test" => 1
+      }
+    })
+
+    #This time, we expect two entries because the second vm_sync_wakeup should have triggered it.
+    expect(dump["pg_spec0_sync_requests"]).to eq(["test", "test"])
+  end
+
+  it "vm_pg_sync_wakeup is called every 20 seconds" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config5c.rb") 
+
+    #Mark page as needing sync
+    dump = ctx.evald %{
+      //Needed to initialize pagers
+      base = _embed("my_controller", 0, {}, null);
+
+      vm_pg_mark_needs_sync("spec", "test");
+    }
+
+    #Call the timer for 1 shot
+    (20*4).times do
+      @driver.int "int_timer", []
+    end
+
+    #First time, the vm_pg_sync_wakeup should not have triggered anything (vm_unsynced still set to 0)
+    expect(ctx.dump("pg_spec0_sync_requests")).to eq(["test"])
+
+    #Call the timer for 1 more shot
+    (20*4).times do
+      @driver.int "int_timer", []
+    end
+
+    #Second time, vm_pg_sync_wakeup should call pager's sync function
+    expect(ctx.dump("pg_spec0_sync_requests")).to eq(["test", "test"])
+
+    #Call the timer for 1 more shot
+    (20*4).times do
+      @driver.int "int_timer", []
+    end
+
+    #Third time, vm_pg_sync_wakeup should call pager's sync function
+    expect(ctx.dump("pg_spec0_sync_requests")).to eq(["test", "test", "test"])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flok
 version: !ruby/object:Gem::Version
-  version: 0.0.79
+  version: 0.0.80
 platform: ruby
 authors:
 - seo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-02 00:00:00.000000000 Z
+date: 2015-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: execjs
@@ -314,9 +314,6 @@ files:
 - app/kern/pagers/pg_net_sim.js
 - app/kern/pagers/pg_sockio.js
 - app/kern/pagers/pg_spec.js
-- app/kern/pagers/spec0.js
-- app/kern/pagers/spec1.js
-- app/kern/pagers/spec2.js
 - app/kern/services/rest.rb
 - app/kern/services/test.rb
 - app/kern/services/vm.rb
@@ -340,7 +337,6 @@ files:
 - docs/images/view_and_spot.png
 - docs/interactive.md
 - docs/kernel_api.md
-- docs/known_issues.md
 - docs/messaging.md
 - docs/mod/controller.md
 - docs/mod/debug.md
@@ -364,6 +360,7 @@ files:
 - docs/services/vm/diff.md
 - docs/services/vm/pagers.md
 - docs/testing.md
+- docs/todo.md
 - flok.gemspec
 - lib/flok.rb
 - lib/flok/build.rb
@@ -1208,6 +1205,7 @@ files:
 - spec/kern/assets/vm/config4.rb
 - spec/kern/assets/vm/config5.rb
 - spec/kern/assets/vm/config5b.rb
+- spec/kern/assets/vm/config5c.rb
 - spec/kern/assets/vm/config6.rb
 - spec/kern/assets/vm/controller0.rb
 - spec/kern/assets/vm/controller0_diff.rb
@@ -1306,6 +1304,7 @@ files:
 - spec/kern/vm_service_mem_pagers_spec.rb
 - spec/kern/vm_service_net_sim_pager_spec.rb
 - spec/kern/vm_service_spec.rb
+- spec/kern/vm_service_unsynced_spec.rb
 - spec/kern/vm_sockio_pager_spec.rb
 - spec/kern/vm_transaction_spec.rb
 - spec/lib/helpers.rb
@@ -2156,6 +2155,7 @@ test_files:
 - spec/kern/assets/vm/config4.rb
 - spec/kern/assets/vm/config5.rb
 - spec/kern/assets/vm/config5b.rb
+- spec/kern/assets/vm/config5c.rb
 - spec/kern/assets/vm/config6.rb
 - spec/kern/assets/vm/controller0.rb
 - spec/kern/assets/vm/controller0_diff.rb
@@ -2254,6 +2254,7 @@ test_files:
 - spec/kern/vm_service_mem_pagers_spec.rb
 - spec/kern/vm_service_net_sim_pager_spec.rb
 - spec/kern/vm_service_spec.rb
+- spec/kern/vm_service_unsynced_spec.rb
 - spec/kern/vm_sockio_pager_spec.rb
 - spec/kern/vm_transaction_spec.rb
 - spec/lib/helpers.rb

data/app/kern/pagers/spec0.js

@@ -1,35 +0,0 @@
-<% if @debug %>
-spec0_data = {};
-spec0_read_count = 0;
-
-function spec0_init(options) {
-  spec0_init_options = options;
-}
-
-function spec0_read_sync(ns, bp, key) {
-  spec0_read_count += 1;
-
-  var info = {
-    key: key,
-    value: spec0_data[key],
-  }
-  int_event(bp, "read_res", info);
-  //vm_cache[ns][key] = spec0_data[key];
-}
-
-function spec0_read(ns, bp, key) {
-  spec0_read_count += 1;
-
-  var info = {
-    key: key,
-    value: spec0_data[key],
-  }
-
-  int_event(bp, "read_res", info);
-  vm_cache_write(ns, key, spec0_data[key]);
-}
-
-function spec0_write(key, value) {
-  spec0_data[key] = value;
-}
-<% end %>

data/app/kern/pagers/spec1.js

@@ -1,24 +0,0 @@
-<% if @debug %>
-spec1_value = "a";
-
-function spec1_init(options) {
-  spec1_init_options = options;
-}
-
-function spec1_read_sync(ns, bp, key) {
-  throw "unsupported"
-}
-
-function spec1_read(ns, bp, key) {
-  var info = {
-    key: key,
-    value: spec1_value,
-  }
-
-  int_event(bp, "read_res", info);
-  vm_cache_write(ns, key, spec1_value);
-
-  //Now change the value
-  spec1_value = "b";
-}
-<% end %>

data/app/kern/pagers/spec2.js

@@ -1,31 +0,0 @@
-<% if @debug %>
-spec2_value = "a";
-
-function spec2_init(options) {
-  spec2_init_options = options;
-}
-
-function spec2_read_sync(ns, bp, key) {
-  throw "unsupported"
-}
-
-function spec2_read(ns, bp, key) {
-  var info = {
-    key: key,
-    value: spec2_value,
-  }
-
-  int_event(bp, "read_res", info);
-  vm_cache_write(ns, key, spec2_value);
-
-  //Now change the value
-  spec2_value = "b";
-}
-
-function spec2_watch(ns, key) {
-}
-
-function spec2_spec_trigger() {
-  vm_notify("user", "my_key");
-}
-<% end %>

data/docs/known_issues.md

@@ -1,7 +0,0 @@
-#Known issues & Bugs
-
-  0000. A `every` event used in a controller's action will time correctly on the first action, but subsequent actions will be off by at most 3 ticks.
-  This is because we do not have any way (currently) to reset the timing queue in the controller as it reisters for all timing events at init. See
-  "Does not call intervals of other actions; and still works when switching back actions" in `spec/kern/controller_spec.rb` 
-  0002. `vm_cache_write_sync_pending` in the `vm` service relies on page_ids, but this would cause a collision on two pages named the same thing. This
-   needs to integrate the namespace.