X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=8sync%2Factors.scm;h=ceb2980f533e93eab250c85e908dd05e6f885edf;hb=fa598a979d510a783f1d6f097f560f23de997c88;hp=04e1c06a4e2b563a7d6dfb2c63b76959cf7ee12f;hpb=2aab08f137540cf22d5f5e32467e838c3ab18637;p=8sync.git

diff --git a/8sync/actors.scm b/8sync/actors.scm
index 04e1c06..ceb2980 100644
--- a/8sync/actors.scm
+++ b/8sync/actors.scm
@@ -25,6 +25,7 @@
   #:use-module (ice-9 match)
   #:use-module (ice-9 pretty-print)
   #:use-module (8sync agenda)
+  #:use-module (8sync rmeta-slot)
   #:export (;; utilities... ought to go in their own module
             big-random-number
             big-random-number-string
@@ -294,34 +295,25 @@ raise an exception if an error."
 
 (define (actor-inheritable-message-handler actor message)
   (define action (message-action message))
-  (define (find-message-handler return)
-    (for-each (lambda (this-class)
-                (define actions
-                  (or (and (class-slot-definition this-class 'actions)
-                           (class-slot-ref this-class 'actions))
-                      '()))
-                (for-each (match-lambda
-                            ((action-name . method)
-                             (when (eq? action-name action)
-                               (return method))))
-                          actions))
-              (class-precedence-list (class-of actor)))
+  (define method
+    (class-rmeta-ref (class-of actor) 'actions action
+                     #:equals? eq? #:cache-set! hashq-set!
+                     #:cache-ref hashq-ref))
+  (unless method
     (throw 'action-not-found
            "No appropriate action handler found for actor"
            #:action action
            #:actor actor
            #:message message))
-  (define method
-    (call/ec find-message-handler))
   (apply method actor message (message-body message)))
 
 (define-syntax-rule (build-actions (symbol method) ...)
   "Construct an alist of (symbol . method), where the method is wrapped
 with wrap-apply to facilitate live hacking and allow the method definition
 to come after class definition."
-  (list
-   (cons (quote symbol)
-         (wrap-apply method)) ...))
+  (build-rmeta-slot
+   (list (cons (quote symbol)
+               (wrap-apply method)) ...)))
 
 (define-class <actor> ()
   ;; An address object
@@ -339,8 +331,15 @@ to come after class definition."
                    #:allocation #:each-subclass
                    #:getter actor-message-handler)
 
+  ;; valid values are:
+  ;;  - #t as in, send the init message, but don't wait (default)
+  ;;  - 'wait, as in wait on the init message
+  ;;  - #f as in don't bother to init
+  (should-init #:init-value #t
+               #:allocation #:each-subclass)
+
   ;; This is the default, "simple" way to inherit and process messages.
-  (actions #:init-value (build-actions
+  (actions #:init-thunk (build-actions
                          ;; Default init method is to do nothing.
                          (*init* (const #f))
                          ;; Default cleanup method is to do nothing.
@@ -391,7 +390,7 @@ to come after class definition."
                       (action ...)
                       slots ...)
   (define-class class inherits
-    (actions #:init-value (build-actions action ...)
+    (actions #:init-thunk (build-actions action ...)
              #:allocation #:each-subclass)
     slots ...))
 
@@ -425,7 +424,7 @@ to come after class definition."
   (prompt #:init-thunk make-prompt-tag
           #:getter hive-prompt)
   (actions #:allocation #:each-subclass
-           #:init-value
+           #:init-thunk
            (build-actions
             ;; This is in the case of an ambassador failing to forward a
             ;; message... it reports it back to the hive
@@ -444,10 +443,14 @@ to come after class definition."
     (hash-map->list (lambda (actor-id actor) actor-id)
                     (hive-actor-registry hive)))
   (for-each (lambda (actor-id)
-              ;; @@: This could maybe just be <-, but we want actors
-              ;;   to be used to the expectation in all circumstances
-              ;;   that their init method is "waited on".
-              (<-wait actor-id '*init*))
+              (let* ((actor (hash-ref (hive-actor-registry hive)
+                                      actor-id)))
+                (match (slot-ref actor 'should-init)
+                  (#f #f)
+                  ('wait
+                   (<-wait actor-id '*init*))
+                  (_
+                   (<- actor-id '*init*)))))
             actor-ids))
 
 (define-method (hive-handle-failed-forward (hive <hive>) message)
@@ -559,7 +562,9 @@ to come after class definition."
                  message))
       actor))
 
-  (define (call-catching-coroutine thunk)
+  ;; TODO: I'm pretty sure we're building up another stack of prompts here
+  ;;   with the way we're doing this.  That's a real problem.
+  (define* (call-catching-coroutine thunk #:optional (catch-errors #t))
     (define queued-error-handling-thunk #f)
     (define (call-catching-errors)
       ;; TODO: maybe parameterize (or attach to hive) and use
@@ -588,7 +593,9 @@ to come after class definition."
       (if queued-error-handling-thunk
           (8sync (queued-error-handling-thunk))))
     (call-with-prompt (hive-prompt hive)
-      call-catching-errors
+      (if catch-errors
+          call-catching-errors
+          thunk)
       (lambda (kont actor message send-options)
         ;; Register the coroutine
         (hash-set! (hive-waiting-coroutines hive)
@@ -638,7 +645,9 @@ to come after class definition."
                result))
             (#f (throw 'no-waiting-coroutine
                        "message in-reply-to tries to resume nonexistent coroutine"
-                       message))))))
+                       message))))
+        ;; no need to catch errors here, there's already an error handler
+        #f))
       ;; Unhandled action for a reply!
       (else
        (throw 'hive-unresumable-coroutine
@@ -684,11 +693,15 @@ that method for documentation."
          (actor (apply make actor-class
                        #:hive hive
                        #:id actor-id
-                       init-args)))
+                       init-args))
+         (actor-should-init (slot-ref actor 'should-init)))
     (hive-register-actor! hive actor)
-    ;; Wait on actor to init
-    (when send-init?
-      (<-wait actor-id '*init*))
+    ;; Maybe run actor init method
+    (when (and send-init? actor-should-init)
+      (let ((send-method
+             (if (eq? actor-should-init 'wait)
+                 <-wait <-)))
+        (send-method actor-id '*init*)))
     ;; return the actor id
     actor-id))