Changeset 33 for branches

Timestamp:

01/12/07 06:44:39 (18 years ago)

Author:

psmith

Message:

yarpc progress...

Location:

branches/home/psmith/restructure

Files:

• run-yarpc.lisp (modified) (1 diff)
• src/buffer/buffer.lisp (modified) (2 diffs)
• src/buffer/nio-buffer-package.lisp (modified) (1 diff)
• src/protocol/yarpc/nio-yarpc-package.lisp (modified) (1 diff)
• src/protocol/yarpc/nio-yarpc.asd (modified) (1 diff)
• src/protocol/yarpc/yarpc-packet-factory.lisp (added)
• src/protocol/yarpc/yarpc-state-machine.lisp (modified) (3 diffs)
• src/statemachine/nio-sm-package.lisp (modified) (1 diff)
• src/statemachine/state-machine.lisp (modified) (1 diff)

branches/home/psmith/restructure/run-yarpc.lisp ¶

@@ -2 +2 @@
 (require :asdf)
 (require :nio-yarpc)
+
 (nio:start-server 'identity 'identity 'nio-yarpc:yarpc-state-machine :host "127.0.0.1")

branches/home/psmith/restructure/src/buffer/buffer.lisp ¶

@@ -119 +119 @@
     byte-buffer))
 
+;reads bytes from byte-buffer and returns a vector (unsigned-byte 8)
+(defmethod bytebuffer-read-vector((bb byte-buffer) &optional (num-bytes-to-read (remaining bb)))
+  (let ((vec  (make-uint8-seq num-bytes-to-read)))
+    (with-slots (buf) bb
+      (inc-position bb (cffi:mem-read-vector vec (buffer-buf bb) :unsigned-char num-bytes-to-read)))
+    vec))
 
-(defmethod get-string((byte-buffer byte-buffer))
-  (flip byte-buffer)
-  (with-slots (position limit buf) byte-buffer
-    (let ((tmp  (make-uint8-seq (remaining byte-buffer))))
-      (inc-position byte-buffer (cffi:mem-read-vector tmp buf :unsigned-char limit))
-      (format t " read: ~A~%" (sb-ext:octets-to-string tmp :external-format :ascii))
-      tmp)))
-    
-;;TODO 
-;;mem-write-vector (vector ptr type &optional (count (length vector)) (offset 0))
-(defmethod bytebuffer-write-string((byte-buffer byte-buffer) str &optional (index 0) (external-format :ascii))
+; Read bytes from bytebuffer abd return a string using the supplied decoding
+;TODO move octets-to-string into nio-compat
+(defmethod bytebuffer-read-string((bb byte-buffer) &optional (num-bytes-to-read (remaining bb)) (external-format :ascii))
+  (sb-ext:octets-to-string (bytebuffer-read-vector bb num-bytes-to-read) :external-format external-format))
+
+
+;; Write bytes from vector vec to bytebuffer
+(defmethod bytebuffer-write-vector((bb byte-buffer) vec)
   :documentation "Returns number of bytes written to bytebuffer"
-  (bytebuffer-write-vector byte-buffer (sb-ext:string-to-octets str :external-format external-format)))
-
-;;TODO rename
-(defmethod bytebuffer-write-vector((byte-buffer byte-buffer) vec &optional (index 0))
-  :documentation "Returns number of bytes written to bytebuffer"
-  (if (> (remaining byte-buffer) 0)
+  (if (> (remaining bb) 0)
       0
       (progn    
-        (clear byte-buffer)
-        (let ((bytes-written (cffi:mem-write-vector vec (buffer-buf byte-buffer) :unsigned-char)))
+        (clear bb)
+        (let ((bytes-written (cffi:mem-write-vector vec (buffer-buf bb) :unsigned-char)))
           (format t "bytebuffer-write-vector -  byteswritten: ~A" bytes-written)
-          (inc-position byte-buffer bytes-written)
+          (inc-position bb bytes-written)
           bytes-written))))
+
+;; Writes data from string str to bytebuffer using specified encoding
+;TODO move string-to-octets into nio-compat
+(defmethod bytebuffer-write-string((bb byte-buffer) str &optional (external-format :ascii))
+  :documentation "Returns number of bytes written to bytebuffer"
+  (bytebuffer-write-vector bb (sb-ext:string-to-octets str :external-format external-format)))
 
 
@@ -169 +173 @@
     (format t "Remaining ~A~%" (remaining mybuf))
 
-    (format t "mybuf string ~A~%" (get-string mybuf))
+    (format t "mybuf string ~A~%" (bytebuffer-read-string mybuf))
 
     (format t "Mybuf (after get-string): ~A~%" mybuf)

branches/home/psmith/restructure/src/buffer/nio-buffer-package.lisp ¶

@@ -28 +28 @@
             
             (:export
-             byte-buffer free-buffer remaining inc-position get-string buffer-buf bytebuffer-write-vector bytebuffer-write-string flip
+             byte-buffer free-buffer remaining inc-position get-string buffer-buf bytebuffer-write-vector bytebuffer-write-string bytebuffer-read-vector bytebuffer-read-string flip
              ))

branches/home/psmith/restructure/src/protocol/yarpc/nio-yarpc-package.lisp ¶

@@ -25 +25 @@
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 |#
-(defpackage :nio-yarpc (:use :cl :nio :nio-buffer)
+(defpackage :nio-yarpc (:use :cl :nio :nio-sm :nio-buffer)
             
             (:export
 
              ;; yarpc-state-machine
-             yarpc-state-machine test-rpc test-rpc-list test-rpc-string
+             yarpc-state-machine yarpc-state-machine-factory test-rpc test-rpc-list test-rpc-string get-packet-factory
              ))

branches/home/psmith/restructure/src/protocol/yarpc/nio-yarpc.asd ¶

@@ -6 +6 @@
 
     :components ((:file "nio-yarpc-package")
-                 (:file "yarpc-state-machine" :depends-on ("nio-yarpc-package"))
+                 (:file "yarpc-packet-factory" :depends-on ("nio-yarpc-package"))
+                 (:file "yarpc-state-machine" :depends-on ("yarpc-packet-factory"))
                  )
 
-    :depends-on (:nio))
+    :depends-on (:nio :nio-sm))

branches/home/psmith/restructure/src/protocol/yarpc/yarpc-state-machine.lisp ¶

@@ -41 +41 @@
 ;; response - who 2 'S
 ;;
-(defclass yarpc-state-machine (async-fd)())
+(defclass yarpc-state-machine (state-machine)())
 
+(defun yarpc-state-machine ()
+    (make-instance 'yarpc-state-machine))
+
+(defparameter yarpc-pf (yarpc-packet-factory))
+
+(defmethod get-packet-factory((sm yarpc-state-machine))
+  yarpc-pf)
 
 ;;TODO move somewhere suitable
@@ -75 +82 @@
   (format stream "#<YARPC-STATE-MACHINE ~A >" (call-next-method sm nil)))
 
-(defmethod process-read((sm yarpc-state-machine))
-  (with-slots (foreign-read-buffer foreign-write-buffer) sm
-    (let ((fn-result (execute-call (sb-ext:octets-to-string (get-string foreign-read-buffer) :external-format :ascii))))
-      (format t "process-read - function result: ~A~%" fn-result)
-      (nio-buffer:bytebuffer-write-string foreign-write-buffer (write-to-string fn-result) 0 :utf-8)
-      (close-sm sm))))
+(defconstant STATE-INITIALISED 0)
+(defconstant STATE-SEND-RESPONSE 1)
 
+(defparameter state STATE-INITIALISED)
 
 (define-condition authorization-error (error) ())
 
+;Process a call method packet, returns 
+(defmethod process-packet ((sm yarpc-state-machine) (call call-method-packet))
+  ;todo change state, create method-response packet and return it
+  ;(assert (eql state 0))
+  (handler-case
+    (let ((result (execute-call (get-call-string call))))
+      (when result 
+        (let ((response-packet (progn 
+                                  (setf state STATE-SEND-RESPONSE)
+                                  (method-response-packet result))))
+          (values response-packet t))))
+    (reader-error (re) (format t "No such function ~A~%" (get-call-string call)))
+    (authorization-error (ae) (format t "Function not declared with defremote ~A~%" (get-call-string call)))))
+
+
 (defun execute-call (call-string)
-  (handler-case
       (let* ((rpc-call-list (read-from-string call-string ))
              (fn (member (symbol-function (first rpc-call-list)) *remote-fns* )))
@@ -92 +110 @@
         (if fn
             (apply (first rpc-call-list) (rest rpc-call-list))
-            (error 'authorization-error)))
-    (reader-error (re) (format t "No such function ~A~%" call-string))))
+            (error 'authorization-error))))
 

branches/home/psmith/restructure/src/statemachine/nio-sm-package.lisp ¶

@@ -30 +30 @@
 
              ;; state-machine
-             state-machine
+             state-machine packet-factory get-packet-factory get-packet
              ))

branches/home/psmith/restructure/src/statemachine/state-machine.lisp ¶

@@ -43 +43 @@
   (format stream "#<STATE-MACHINE ~A >" (call-next-method sm nil)))
 
+(defgeneric process-packet(state-machine packet))
+
+(defgeneric get-packet-factory(state-machine))
+
 (defmethod process-read((sm state-machine))
   (with-slots (foreign-read-buffer foreign-write-buffer) sm
-    (let ((fn-result (execute-call (sb-ext:octets-to-string (get-string foreign-read-buffer) :external-format :ascii))))
-      (format t "process-read - function result: ~A~%" fn-result)
-      (nio-buffer:bytebuffer-write-string foreign-write-buffer (write-to-string fn-result) 0 :utf-8)
-      (close-sm sm))))
+    (let ((incomming-packet (get-packet (get-packet-factory sm) foreign-read-buffer)))
+      (format t "state-machine::process-read - incomming packet: ~A~%" incomming-packet)
+      (when incomming-packet 
+        (multiple-value-bind (ret-packet close) (process-packet sm incomming-packet)
+          (format t "state-machine::process-read - return packet: ~A~%" ret-packet)
+          (when ret-packet (put-packet ret-packet foreign-write-buffer))
+          (if close
+            (close-sm sm)
+            ))))))
 
 
+
+(defclass packet-factory ()
+  ())
+  
+; Get the packet in buf using the packet factory
+(defgeneric get-packet (packet-factory buf))
+
+; Write the packet to the buffer
+(defun put-packet (packet buf)
+  (nio-buffer:bytebuffer-write-vector buf (get-bytes packet)))