flok 0.0.72 → 0.0.73

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d06f92c68324984f4e293390562ef487283971fd
-  data.tar.gz: 40c7e7f381e3a6630c1bac4935ce0c660adb183b
+  metadata.gz: 6c9f17f929ac1f53925b9f3a7f1d8eb69db61d3f
+  data.tar.gz: c156cf2897629e2d04a2a368eb3d0685ed3ceb29
 SHA512:
-  metadata.gz: a15900ee9f4ef22c576c48ab195f1669495450e211ec2b2c8791cc845fca3208e30513b08cb8878064ef75eaca787f34c6c8c621040b2824c65a494ce8da663e
-  data.tar.gz: 45edc71adc819e2d0b994e7ee746aa6d4da654b57fbcd5e5bbcdbd49cd3731303342a885a5df5781aa91473878089b8f43b4d65a8a02fc9f4591585ca65a3e97
+  metadata.gz: 11bdbc991e2c88768af5b24e0c23471029f9f797ba139b3eabf84367d16fa9cc6c3ae185c2c3eaae870afca42244cd3a63687bb1a7acdc95ac31ab771cb96104
+  data.tar.gz: 876fb2e35de2c656e9f53e9d503ee9f44d7ee4cfc091c848d4e4101be853b2afcef22b4c4a55ef7067ca542908b51d5e47ada3b29083bc3b1ac298cbac92f0de

data/app/kern/pagers/pg_sockio.js

@@ -1,5 +1,31 @@
 //Configure pg_sockio
 <% [0].each do |i| %>
+  //Destination for events sent from the sockio driver
+  function __pg_sockio<%= i %>_xevent_handler(ep, ename, einfo) {
+    if (ename === "update") {
+      //If changes_id was given
+      if (einfo.changes_id !== undefined) {
+        vm_mark_changes_synced(vm_cache[pg_sockio<%= i %>_ns][einfo.page._id], einfo.changes_id)
+      }
+
+      //If page exists, then we need to rebase the page, this will actually
+      //modify einfo.page. If the cached entry has no changes, then nothing
+      //is done.
+      if (vm_cache[pg_sockio<%= i %>_ns][einfo.page._id] !== undefined) {
+        vm_rebase(vm_cache[pg_sockio<%= i %>_ns][einfo.page._id], einfo.page);
+      }
+
+      //Write out page
+      vm_transaction_begin();
+        vm_cache_write(pg_sockio<%= i %>_ns, einfo.page);
+      vm_transaction_end();
+    } else {
+      <% if @debug %>
+        throw "pg_sockio<%= i %>_xevent_handler received an event called: " + ename + "that it does not know how to handle. This event should never have even been forwarded, but you may have missed adding the handler code if you did request a forward"
+      <% end %>
+    }
+  } 
+
   function pg_sockio<%= i %>_init(ns, options) {
     pg_sockio<%= i %>_ns = ns;
 
@@ -11,22 +37,9 @@
       pg_sockio<%= i %>_spec_did_init = true;
     <% end %>
 
-    //Destination for events sent from the sockio driver
-    function pg_sockio<%= i %>_xevent_handler(ep, ename, einfo) {
-      if (ename === "update") {
-        vm_transaction_begin();
-        vm_cache_write(pg_sockio<%= i %>_ns, einfo.page);
-        vm_transaction_end();
-      } else {
-        <% if @debug %>
-        throw "pg_sockio<%= i %>_xevent_handler received an event called: " + ename + "that it does not know how to handle. This event should never have even been forwarded, but you may have missed adding the handler code if you did request a forward"
-        <% end %>
-      }
-    } 
-
     //Register the base address for the socket and the destination for events
     pg_sockio<%= i %>_bp = tels(1);
-    reg_evt(pg_sockio<%= i %>_bp, pg_sockio<%= i %>_xevent_handler);
+    reg_evt(pg_sockio<%= i %>_bp, __pg_sockio<%= i %>_xevent_handler);
 
     SEND("main", "if_sockio_init", options.url, pg_sockio<%= i %>_bp);
 

data/docs/services/vm/pagers.md

@@ -80,6 +80,7 @@ This pager connects to a socket.io server via the `sockio` module.
         * writes directly to `vm_cache` and notifies the server of the creation via `/create` with `page:`
   * **Socket.IO Event Handlers **
     * `update` - A page has been updated. This may either indicate an update or write. The page will be integrated into `vm_cache` via a rebased if it
-        already exists or a direct write if it dosen't already exist. Contains one field `page:` that contains the page.
+        already exists or a direct write if it dosen't already exist. Contains one field `page:` that contains the page and a possible `changes_id`
+        if the update is in response to some pages commited to the page.
   * **Spec**
     * If `@debug`, then `sockio{N}_spec_did_init` will be true

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.72"
+  VERSION = "0.0.73"
 end

data/spec/kern/assets/vm/pg_sockio/watch2.rb

@@ -0,0 +1,22 @@
+controller :my_controller do
+  services :vm
+
+  on_entry %{
+    read_res_params = [];
+  }
+
+  action :my_action do
+    on_entry %{
+      var watch_info = {
+        ns: "sockio",
+        id: "test", 
+      };
+
+      Request("vm", "watch", watch_info);
+    }
+
+    on "read_res", %{
+      read_res_params.push(JSON.parse(JSON.stringify(params)));
+    }
+  end
+end

data/spec/kern/vm_sockio_pager_spec.rb

@@ -77,7 +77,344 @@ RSpec.describe "kern:sockio_pager" do
     }], 1
   end
 
-  it "Does write a page to vm_cache that dosen't already exist when the page receives an 'update' response from the external socket.io" do
+  it "Does write a page to vm_cache that **does** already exist as <unbased, nochanges> the page receives an 'update' response from the external socket.io without a changes id" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/watch2.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
+    dump = ctx.evald %{
+      //Call embed on main root view
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      //pg_sockio0 socket address & the endpoint for the event callback
+      dump.pg_sockio0_bp = pg_sockio0_bp;
+    }
+
+    #sockio driver should have been signaled (which it should respond asynchronously, and presumabely, after the disk)
+    @driver.ignore_up_to "if_sockio_send"
+    @driver.mexpect "if_sockio_send", [Integer, "watch", {
+      "page_id" => "test"
+    }], 1
+
+    #The disk should have been signaled
+    @driver.ignore_up_to "if_per_get"
+    @driver.mexpect "if_per_get", ["vm", "sockio", "test"], 2
+
+
+    #The disk should respond with a page
+    @driver.int "int_per_get_res", ["vm", "sockio", "test", {
+      "_id" => "test",
+      "_next" => nil,
+      "_head" => nil,
+      "entries" => [
+        {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+        {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+      ]
+    }]
+
+    #We (driver sockio) received a watch request for a page with the id 'test'
+    #Now we are imagining that the socket.io driver received back some
+    #data and is now signaling to the kernel that data is available (as it sends to an
+    #event endpoint equal to the socket bp)
+    @driver.int "int_event", [dump["pg_sockio0_bp"], "update", {page: {
+      _id: "test",
+      _next: nil,
+      _head: nil,
+      entries: [
+        {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"}
+      ],
+    }}]
+
+    post_read_res_dump = ctx.evald %{
+      for (var i = 0; i < 100; ++i) {
+        //Drain queue (vm_cache_write defers to controller)
+        int_dispatch([]);
+      }
+
+      dump.read_res_params = read_res_params;
+    }
+
+    #The controller should have received a notification that a page was updated twice, one 
+    #for the disk response and one for the pager response
+    expect(post_read_res_dump["read_res_params"].length).to eq(2)
+    expect(post_read_res_dump["read_res_params"][0]["entries"]).to eq([
+      {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+      {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+    ])
+    expect(post_read_res_dump["read_res_params"][1]["entries"]).to eq([
+      {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"}
+    ])
+  end
+
+  it "Does write a page to vm_cache that **does** already exist as <unbased, changes> receives an 'update' response from the external socket.io without a changes_id" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/watch2.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
+    dump = ctx.evald %{
+      //Call embed on main root view
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      //pg_sockio0 socket address & the endpoint for the event callback
+      dump.pg_sockio0_bp = pg_sockio0_bp;
+    }
+
+    #sockio driver should have been signaled (which it should respond asynchronously, and presumabely, after the disk)
+    @driver.ignore_up_to "if_sockio_send"
+    @driver.mexpect "if_sockio_send", [Integer, "watch", {
+      "page_id" => "test"
+    }], 1
+
+    #The disk should have been signaled
+    @driver.ignore_up_to "if_per_get"
+    @driver.mexpect "if_per_get", ["vm", "sockio", "test"], 2
+
+
+    #The disk should respond with a page that contains changes
+    @driver.int "int_per_get_res", ["vm", "sockio", "test", {
+      "_id" => "test",
+      "_next" => nil,
+      "_head" => nil,
+      "entries" => [
+        {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+        {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+      ],
+      "__changes" => [
+        ["+", 0, {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"}],
+        ["+", 1, {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}],
+        ["-", "foo3"],
+      ],
+      "__changes_id" => "foo"
+    }]
+
+    #We (driver sockio) received a watch request for a page with the id 'test'
+    #Now we are imagining that the socket.io driver received back some
+    #data and is now signaling to the kernel that data is available (as it sends to an
+    #event endpoint equal to the socket bp)
+    @driver.int "int_event", [dump["pg_sockio0_bp"], "update", {page: {
+      _id: "test",
+      _next: nil,
+      _head: nil,
+      entries: [
+        {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"},
+        {"_id" => "foo4", "_sig" => "foo4", "value" => "bar4"}
+      ],
+    }}]
+
+    post_read_res_dump = ctx.evald %{
+      for (var i = 0; i < 100; ++i) {
+        //Drain queue (vm_cache_write defers to controller)
+        int_dispatch([]);
+      }
+
+      dump.read_res_params = read_res_params;
+    }
+
+    #The controller should have received a notification that a page was updated twice, one 
+    #for the disk response and one for the pager response
+    expect(post_read_res_dump["read_res_params"].length).to eq(2)
+    expect(post_read_res_dump["read_res_params"][0]["entries"]).to eq([
+      {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+      {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+    ])
+
+    #Next page should be rebased ontop of the incomming page, such that changes are played *over* it
+    #which includes deletion of foo3
+    expect(post_read_res_dump["read_res_params"][1]["entries"]).to eq([
+      {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+      {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"},
+      {"_id" => "foo4", "_sig" => "foo4", "value" => "bar4"},
+    ])
+  end
+
+  it "Does write a page to vm_cache that **does** already exist as <based<unbased, changes>, changes> receives an 'update' response from the external socket.io without a changes_id" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/watch2.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
+    dump = ctx.evald %{
+      //Call embed on main root view
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      //pg_sockio0 socket address & the endpoint for the event callback
+      dump.pg_sockio0_bp = pg_sockio0_bp;
+    }
+
+    #sockio driver should have been signaled (which it should respond asynchronously, and presumabely, after the disk)
+    @driver.ignore_up_to "if_sockio_send"
+    @driver.mexpect "if_sockio_send", [Integer, "watch", {
+      "page_id" => "test"
+    }], 1
+
+    #The disk should have been signaled
+    @driver.ignore_up_to "if_per_get"
+    @driver.mexpect "if_per_get", ["vm", "sockio", "test"], 2
+
+
+    #The disk should respond with a page that contains <based<nobase, changes>, changes>
+    @driver.int "int_per_get_res", ["vm", "sockio", "test", {
+      "_id" => "test",
+      "_next" => nil,
+      "_head" => nil,
+      "entries" => [
+        {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+        {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+      ],
+      "__changes" => [
+        ["+", 0, {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"}],
+        ["+", 1, {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}],
+        ["-", "foo3"],
+      ],
+      "__changes_id" => "foo",
+      "__base" => {
+        "_id" => "test",
+        "_next" => nil,
+        "_head" => nil,
+        "entries" => [
+          {"_id" => "fooX", "_sig" => "fooX", "value" => "barX"},
+          {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"}
+        ],
+        "__changes_id" => "foo2",
+        "__changes" => [
+          ["-", "fooX"],
+          ["+", 1, {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"}]
+        ]
+      }
+    }]
+
+    #We (driver sockio) received a watch request for a page with the id 'test'
+    #Now we are imagining that the socket.io driver received back some
+    #data and is now signaling to the kernel that data is available (as it sends to an
+    #event endpoint equal to the socket bp)
+    @driver.int "int_event", [dump["pg_sockio0_bp"], "update", {page: {
+      _id: "test",
+      _next: nil,
+      _head: nil,
+      entries: [
+        {"_id" => "foo4", "_sig" => "foo4", "value" => "bar4"},
+        {"_id" => "foo5", "_sig" => "foo5", "value" => "bar5"},
+        {"_id" => "fooX", "_sig" => "fooX", "value" => "barX"},
+      ],
+    }}]
+
+    post_read_res_dump = ctx.evald %{
+      for (var i = 0; i < 100; ++i) {
+        //Drain queue (vm_cache_write defers to controller)
+        int_dispatch([]);
+      }
+
+      dump.read_res_params = read_res_params;
+    }
+
+    #The controller should have received a notification that a page was updated twice, one 
+    #for the disk response and one for the pager response
+    expect(post_read_res_dump["read_res_params"].length).to eq(2)
+    expect(post_read_res_dump["read_res_params"][0]["entries"]).to eq([
+      {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+      {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+    ])
+
+    #Next version is a double replay.  First, the server page is called the new 'base', then changes from the 
+    #old base are played ontop of the server page. Then the top-level changes are recalculated based on this new page,
+    #and then replayed on the server's page *again* (a linked copy where the first replayed sits at __base.
+    expect(post_read_res_dump["read_res_params"][1]["entries"]).to eq([
+        {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+        {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"},
+        {"_id" => "foo4", "_sig" => "foo4", "value" => "bar4"},
+        {"_id" => "foo5", "_sig" => "foo5", "value" => "bar5"},
+    ])
+  end
+
+  it "Does write a page to vm_cache that **does** already exist as <unbased, changes> receives an 'update' response from the external socket.io **with** an existing changes_id" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/watch2.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
+    dump = ctx.evald %{
+      //Call embed on main root view
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      //pg_sockio0 socket address & the endpoint for the event callback
+      dump.pg_sockio0_bp = pg_sockio0_bp;
+    }
+
+    #sockio driver should have been signaled (which it should respond asynchronously, and presumabely, after the disk)
+    @driver.ignore_up_to "if_sockio_send"
+    @driver.mexpect "if_sockio_send", [Integer, "watch", {
+      "page_id" => "test"
+    }], 1
+
+    #The disk should have been signaled
+    @driver.ignore_up_to "if_per_get"
+    @driver.mexpect "if_per_get", ["vm", "sockio", "test"], 2
+
+
+    #The disk should respond with a page that contains changes
+    @driver.int "int_per_get_res", ["vm", "sockio", "test", {
+      "_id" => "test",
+      "_next" => nil,
+      "_head" => nil,
+      "entries" => [
+        {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+        {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+      ],
+      "__changes" => [
+        ["+", 0, {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"}],
+        ["+", 1, {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}],
+        ["-", "foo3"],
+      ],
+      "__changes_id" => "foo"
+    }]
+
+    #We (driver sockio) received a watch request for a page with the id 'test'
+    #Now we are imagining that the socket.io driver received back some
+    #data and is now signaling to the kernel that data is available (as it sends to an
+    #event endpoint equal to the socket bp)
+    @driver.int "int_event", [dump["pg_sockio0_bp"], "update", {
+      page: {
+        _id: "test",
+        _next: nil,
+        _head: nil,
+        entries: [
+          {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"},
+          {"_id" => "foo4", "_sig" => "foo4", "value" => "bar4"}
+        ],
+      }, 
+      changes_id: "foo"
+    }]
+
+    post_read_res_dump = ctx.evald %{
+      for (var i = 0; i < 100; ++i) {
+        //Drain queue (vm_cache_write defers to controller)
+        int_dispatch([]);
+      }
+
+      dump.read_res_params = read_res_params;
+    }
+
+    #The controller should have received a notification that a page was updated twice, one 
+    #for the disk response and one for the pager response
+    expect(post_read_res_dump["read_res_params"].length).to eq(2)
+    expect(post_read_res_dump["read_res_params"][0]["entries"]).to eq([
+      {"_id" => "foo1", "_sig" => "foo1", "value" => "bar1"},
+      {"_id" => "foo2", "_sig" => "foo2", "value" => "bar2"}
+    ])
+    #Changes should be present in second copy
+    expect(post_read_res_dump["read_res_params"][0]["__changes_id"]).not_to eq(nil)
+
+
+    #Next page should be rebased ontop of the incomming page, however, since changes_id matches
+    #current changes on the page, the page is just replaced (as changes were aknowledged and there
+    #is nothing to repair)
+    expect(post_read_res_dump["read_res_params"][1]["entries"]).to eq([
+      {"_id" => "foo3", "_sig" => "foo3", "value" => "bar3"},
+      {"_id" => "foo4", "_sig" => "foo4", "value" => "bar4"},
+    ])
+    #Changes should not be present in second copy
+    expect(post_read_res_dump["read_res_params"][1]["__changes_id"]).to eq(nil)
+  end
+
+  it "Does write a page to vm_cache that **does not** already exist when the page receives an 'update' response from the external socket.io" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/watch.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
     dump = ctx.evald %{
       //Call embed on main root view

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flok
 version: !ruby/object:Gem::Version
-  version: 0.0.72
+  version: 0.0.73
 platform: ruby
 authors:
 - seo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-22 00:00:00.000000000 Z
+date: 2015-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: execjs
@@ -1260,6 +1260,7 @@ files:
 - spec/kern/assets/vm/pg_sockio/config_no_url.rb
 - spec/kern/assets/vm/pg_sockio/nothing.rb
 - spec/kern/assets/vm/pg_sockio/watch.rb
+- spec/kern/assets/vm/pg_sockio/watch2.rb
 - spec/kern/assets/vm/service0.rb
 - spec/kern/assets/vm/service_controller0.rb
 - spec/kern/assets/vm/vm_commit_pages.js
@@ -2197,6 +2198,7 @@ test_files:
 - spec/kern/assets/vm/pg_sockio/config_no_url.rb
 - spec/kern/assets/vm/pg_sockio/nothing.rb
 - spec/kern/assets/vm/pg_sockio/watch.rb
+- spec/kern/assets/vm/pg_sockio/watch2.rb
 - spec/kern/assets/vm/service0.rb
 - spec/kern/assets/vm/service_controller0.rb
 - spec/kern/assets/vm/vm_commit_pages.js