hakuban 0.6.1 → 0.6.2

package/hakuban-with-wasm.js

@@ -1539,17 +1539,43 @@ Queue = class Queue {
 
 };
 
+var ObjectManagerBuilder = class ObjectManagerBuilder {
+  constructor(contract, managed_object_class) {
+    this.contract = contract;
+    this.managed_object_class = managed_object_class;
+    this._on_exception_policy = "retry";
+    this._retry_backoff = [0.01, 0.1, 1.0, 10.0];
+    this._terminate_on_deactivation = false;
+  }
+
+  on_exception(policy) {
+    this._on_exception_policy = policy;
+    return this;
+  }
+
+  //terminate_on_deactivation: ()->
+  //	@terminate_on_deactivation = true
+  //	@
+  retry_backoff(times) {
+    this._retry_backoff = times;
+    return this;
+  }
+
+  with_async(block) {
+    return new ObjectManager(this.contract, this.managed_object_class, block, this._retry_backoff, this._terminate_on_deactivation, this._on_exception_policy);
+  }
+
+};
+
 var ObjectManager = class ObjectManager {
-  constructor(contract, object_class, block1) {
+  constructor(contract, object_class, block, retry_backoff, terminate_on_deactivation, on_exception_policy) {
     var event_loop_stop_requested;
     this.objects = this.objects.bind(this);
     this.object = this.object.bind(this);
     this.drop = this.drop.bind(this);
     this.contract = contract;
-    this.object_class = object_class;
-    this.block = block1;
-    this._objects = {};
-    this.running_handlers = {};
+    this._existing_objects = {};
+    this._active_objects = {};
     this.event_queue = new Queue();
     //TODO: make one loop out of following two
     event_loop_stop_requested = new Promise((event_loop_stop) => {
@@ -1569,79 +1595,109 @@ var ObjectManager = class ObjectManager {
       return resolve();
     });
     this.async_loop_stopped = new Promise(async(resolve, reject) => {
-      var _key, event, key, object, ref, ref1;
+      var base, base1, descriptor_for_lambda, error, event, heal_multiplier, i, interval_since_last_exception, key, len, name, name1, object, ref, ref1;
       while ((event = (await this.event_queue.shift())) != null) {
         switch (event.action) {
           case "Insert":
-            if (this._objects[event.descriptor.hash()] != null) {
-              throw "Double insert";
-            }
-            this._objects[event.descriptor.hash()] = new this.object_class(this.contract, event.descriptor);
-            if (this.block != null) {
-              this.event_queue.push({
-                action: "HandlerStart",
-                descriptor: event.descriptor
-              });
-            }
-            break;
           case "Change":
-            if (this._objects[event.descriptor.hash()] == null) {
-              throw "Uh, oh, object missing :(";
-            }
-            this._objects[event.descriptor.hash()].do_change("change");
-            break;
           case "Remove":
-            if (this._objects[event.descriptor.hash()] == null) {
-              throw "Trying to remove non-existing object. Sad.";
+          case "Stopped":
+          case "Timer":
+            object = (base = this._existing_objects)[name = event.descriptor.hash()] || (base[name] = new object_class(this.contract, event.descriptor));
+            if (!object.running && (object.block_result != null)) {
+              error = (await object.block_result);
+              object.block_result = null;
+              if (object.last_exception_at != null) {
+                interval_since_last_exception = Date.now() - object.last_exception_at;
+                heal_multiplier = 10;
+                object.current_delay_index -= Math.floor(interval_since_last_exception / (retry_backoff[retry_backoff.length - 1] * 1000.0 * heal_multiplier));
+                if (object.current_delay_index < 0) {
+                  object.current_delay_index = 0;
+                }
+              }
+              if (error != null) {
+                switch (on_exception_policy) {
+                  case "throw":
+                  case "raise":
+                    throw error.exception;
+                  case "retry":
+                    object.last_exception_at = Date.now();
+                    object.earliest_next_run = Date.now() + retry_backoff[object.current_delay_index] * 1000.0;
+                    //wrapped to avoid weird capture effects of coffee
+                    (function(lambda_sleep_time, lambda_descriptor, lambda_event_queue) {
+                      return setTimeout((() => {
+                        return lambda_event_queue.push({
+                          action: "Timer",
+                          descriptor: lambda_descriptor
+                        });
+                      }), lambda_sleep_time);
+                    })(object.earliest_next_run - Date.now(), event.descriptor, this.event_queue);
+                    if (object.current_delay_index < retry_backoff.length - 1) {
+                      object.current_delay_index += 1;
+                    }
+                }
+              }
             }
-            this._objects[event.descriptor.hash()].do_change("remove");
-            delete this._objects[event.descriptor.hash()];
-            break;
-          case "HandlerStart":
-            if (((object = this._objects[event.descriptor.hash()]) != null) && !object.handler_already_run && (this.running_handlers[event.descriptor.hash()] == null)) {
-              //wrapped to avoid weird capture effects
-              this.running_handlers[event.descriptor.hash()] = (function(descriptor, object, block, event_queue) {
-                return new Promise(async function(handler_resolve, handler_reject) {
-                  await object.run(block);
-                  event_queue.push({
-                    action: "HandlerFinished",
-                    descriptor: descriptor
+            //when "ignore_failing_descriptor"
+            //when "drop_contract"
+            if (object.check_active()) {
+              if ((block != null) && !object.running && ((object.earliest_next_run == null) || Date.now() >= object.earliest_next_run)) {
+                descriptor_for_lambda = event.descriptor;
+                object.running = true;
+                //wrapped to avoid weird capture effects of coffee
+                object.block_result = (function(descriptor, object, block, event_queue) {
+                  return new Promise(async(resolve, reject) => {
+                    try {
+                      await object.run(block);
+                      return resolve(void 0);
+                    } catch (error1) {
+                      error = error1;
+                      console.error("Exception in hakuban manager lambda:", error);
+                      return resolve(error);
+                    } finally {
+                      object.running = false;
+                      event_queue.push({
+                        action: "Stopped",
+                        descriptor: descriptor_for_lambda
+                      });
+                    }
                   });
-                  return handler_resolve();
-                });
-              })(event.descriptor, object, this.block, this.event_queue);
-            }
-            break;
-          case "HandlerFinished":
-            if (this.running_handlers[event.descriptor.hash()] == null) {
-              throw "Handler finished but it was not running. That sucks.";
-            }
-            delete this.running_handlers[event.descriptor.hash()];
-            if (this._objects[event.descriptor.hash()] != null) {
-              this.event_queue.push({
-                action: "HandlerStart",
-                descriptor: event.descriptor
-              });
+                })(event.descriptor, object, block, this.event_queue);
+              }
+              (base1 = this._active_objects)[name1 = event.descriptor.hash()] || (base1[name1] = object);
+              object.change();
+            } else {
+              delete this._active_objects[event.descriptor.hash()];
+              if (object.running) {
+                object.stop();
+              } else {
+                delete this._existing_objects[event.descriptor.hash()];
+              }
             }
             break;
           case "Drop":
             this.event_loop_stop();
             await this.event_loop_stopped;
-            ref = this._objects;
-            for (_key in ref) {
-              object = ref[_key];
-              object.do_change("remove");
+            ref = {...this._existing_objects};
+            for (key in ref) {
+              object = ref[key];
+              if (object.running) {
+                object.stop();
+              } else {
+                delete this._existing_objects[key];
+              }
             }
-            while (Object.keys(this.running_handlers).length > 0) {
+            while (Object.keys(this._existing_objects).length > 0) {
               event = (await this.event_queue.shift());
-              if (event.action === "HandlerFinished") {
-                delete this.running_handlers[event.descriptor.hash()];
+              if (event.action === "Stopped") {
+                delete this._existing_objects[event.descriptor.hash()];
               }
             }
             this.event_queue.clear();
-            ref1 = this._objects;
-            for (key in ref1) {
-              delete this._objects[key];
+            ref1 = Object.keys(this._active_objects);
+            for (i = 0, len = ref1.length; i < len; i++) {
+              key = ref1[i];
+              delete this._active_objects[key];
             }
             this.contract.drop();
             this.contract = null;
@@ -1657,11 +1713,11 @@ var ObjectManager = class ObjectManager {
   }
 
   objects() {
-    return Object.values(this._objects);
+    return Object.values(this._active_objects);
   }
 
   object() {
-    return Object.values(this._objects)[0];
+    return Object.values(this._active_objects)[0];
   }
 
   async drop() {
@@ -1680,15 +1736,15 @@ var ManagedObject = class ManagedObject {
     this.run = this.run.bind(this);
     this.next_event = this.next_event.bind(this);
     this.next_change = this.next_change.bind(this);
-    this.do_change = this.do_change.bind(this);
+    this.change = this.change.bind(this);
+    this.stop = this.stop.bind(this);
     this.contract = contract;
     this.descriptor = descriptor1;
     this._changes = new Queue();
-    this.handler_already_run = false;
+    this.current_delay_index = 0;
   }
 
   async run(handler) {
-    this.handler_already_run = true;
     return (await handler(this));
   }
 
@@ -1701,14 +1757,18 @@ var ManagedObject = class ManagedObject {
       switch ((await this._changes.shift())) {
         case "change":
           return true;
-        case "remove":
+        case "stop":
           return false;
       }
     }
   }
 
-  do_change(change) {
-    return this._changes.push(change);
+  change() {
+    return this._changes.push("change");
+  }
+
+  stop() {
+    return this._changes.push("stop");
   }
 
 };
@@ -1983,7 +2043,7 @@ ObjectObserve = class ObjectObserve {
     this.drop = this.drop.bind(this);
     this.object_state = this.object_state.bind(this);
     this.events = this.events.bind(this);
-    this.async = this.async.bind(this);
+    this.manage = this.manage.bind(this);
     this.local_node = local_node;
     this.descriptor = descriptor1;
     this.deserializer = deserializer;
@@ -2028,9 +2088,9 @@ ObjectObserve = class ObjectObserve {
     return new ObjectDescriptorEvents(hakuban_object_observe_events_get(this.pointer));
   }
 
-  async(lambda) {
-    var ObservedObject;
-    ObservedObject = class ObservedObject extends ManagedObject {
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
       state() {
         var ref;
         return (ref = this.contract) != null ? ref.object_state() : void 0;
@@ -2041,8 +2101,12 @@ ObjectObserve = class ObjectObserve {
         return (ref = this.contract) != null ? (ref1 = ref.object_state()) != null ? ref1.data : void 0 : void 0;
       }
 
+      check_active() {
+        return !!this.state();
+      }
+
     };
-    return new ObjectManager(this, ObservedObject, lambda);
+    return new ObjectManagerBuilder(this, ManagedObject$1);
   }
 
 };
@@ -2060,7 +2124,7 @@ ObjectExpose = class ObjectExpose {
     this.assigned = this.assigned.bind(this);
     this.desynchronize = this.desynchronize.bind(this);
     this.events = this.events.bind(this);
-    this.async = this.async.bind(this);
+    this.manage = this.manage.bind(this);
     this.local_node = local_node;
     this.descriptor = descriptor1;
     this.serializer = serializer;
@@ -2107,9 +2171,9 @@ ObjectExpose = class ObjectExpose {
     return new ObjectDescriptorEvents(hakuban_object_expose_events_get(this.pointer));
   }
 
-  async(lambda) {
-    var ExposedObject;
-    ExposedObject = class ExposedObject extends ManagedObject {
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
       constructor(contract, descriptor) {
         super(contract, descriptor);
         this.run = this.run.bind(this);
@@ -2123,45 +2187,49 @@ ObjectExpose = class ObjectExpose {
 
       async run(handler) {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         await super.run(handler);
         return (ref = this.contract) != null ? ref.desynchronize(this._assignment) : void 0;
       }
 
       do_change(change) {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         this._assignment = (ref = this.contract) != null ? ref.assignment() : void 0;
         return super.do_change(change);
       }
 
       assignment() {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         return (ref = this.contract) != null ? ref.assignment() : void 0;
       }
 
       assigned() {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         return (ref = this.contract) != null ? ref.assigned() : void 0;
       }
 
       set_state(version, cooked_data, data_type = []) {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         return (ref = this.contract) != null ? ref.set_object_state(version, cooked_data, data_type, this._assignment) : void 0;
       }
 
       set_data(data) {
         var timestamp;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         timestamp = new Date().getTime();
         return this.set_state([1, Math.floor(timestamp / 1000), timestamp - Math.floor(timestamp / 1000) * 1000, 0], data);
       }
 
+      check_active() {
+        return this.assigned();
+      }
+
     };
-    return new ObjectManager(this, ExposedObject, lambda);
+    return new ObjectManagerBuilder(this, ManagedObject$1);
   }
 
 };
@@ -2176,7 +2244,6 @@ TagObserve = class TagObserve {
     this.drop = this.drop.bind(this);
     this.object_descriptors = this.object_descriptors.bind(this);
     this.object_state = this.object_state.bind(this);
-    this.async = this.async.bind(this);
     this.local_node = local_node;
     this.descriptor = descriptor1;
     this.deserializer = deserializer;
@@ -2232,9 +2299,9 @@ TagObserve = class TagObserve {
     return new ObjectDescriptorEvents(hakuban_tag_observe_events_get(this.pointer));
   }
 
-  async(lambda) {
-    var ObservedObject;
-    ObservedObject = class ObservedObject extends ManagedObject {
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
       state() {
         var ref;
         return (ref = this.contract) != null ? ref.object_state(this.descriptor) : void 0;
@@ -2245,8 +2312,12 @@ TagObserve = class TagObserve {
         return (ref = this.contract) != null ? (ref1 = ref.object_state(this.descriptor)) != null ? ref1.data : void 0 : void 0;
       }
 
+      check_active() {
+        return !!this.state();
+      }
+
     };
-    return new ObjectManager(this, ObservedObject, lambda);
+    return new ObjectManagerBuilder(this, ManagedObject$1);
   }
 
 };
@@ -2265,7 +2336,7 @@ TagExpose = class TagExpose {
     this.assigned = this.assigned.bind(this);
     this.desynchronize = this.desynchronize.bind(this);
     this.events = this.events.bind(this);
-    this.async = this.async.bind(this);
+    this.manage = this.manage.bind(this);
     this.local_node = local_node;
     this.descriptor = descriptor1;
     this.serializer = serializer;
@@ -2329,9 +2400,9 @@ TagExpose = class TagExpose {
     return new ObjectDescriptorEvents(hakuban_tag_expose_events_get(this.pointer));
   }
 
-  async(lambda) {
-    var ExposedObject;
-    ExposedObject = class ExposedObject extends ManagedObject {
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
       constructor(contract, descriptor) {
         super(contract, descriptor);
         this.run = this.run.bind(this);
@@ -2345,45 +2416,49 @@ TagExpose = class TagExpose {
 
       async run(handler) {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         await super.run(handler);
         return (ref = this.contract) != null ? ref.desynchronize(this.descriptor, this._assignment) : void 0;
       }
 
       do_change(change) {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         this._assignment = (ref = this.contract) != null ? ref.assignment(this.descriptor) : void 0;
         return super.do_change(change);
       }
 
       assignment() {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         return (ref = this.contract) != null ? ref.assignment(this.descriptor) : void 0;
       }
 
       assigned() {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         return (ref = this.contract) != null ? ref.assigned(this.descriptor) : void 0;
       }
 
       set_state(version, cooked_data, data_type = []) {
         var ref;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         return (ref = this.contract) != null ? ref.set_object_state(this.descriptor, version, cooked_data, data_type, this._assignment) : void 0;
       }
 
       set_data(data) {
         var timestamp;
-        boundMethodCheck(this, ExposedObject);
+        boundMethodCheck(this, ManagedObject$1);
         timestamp = new Date().getTime();
         return this.set_state([1, Math.floor(timestamp / 1000), timestamp - Math.floor(timestamp / 1000) * 1000, 0], data);
       }
 
+      check_active() {
+        return this.assigned();
+      }
+
     };
-    return new ObjectManager(this, ExposedObject, lambda);
+    return new ObjectManagerBuilder(this, ManagedObject$1);
   }
 
 };