add tutorials code, fix markdown

Author: des75

_includes/cl-bunny/tutorials/tutorial-five-cl.md

@@ -14,12 +14,14 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
+
 # RabbitMQ tutorial - Topics
 
 ## Topics
+
 ### (using [cl-bunny](http://cl-rabbit.io/cl-bunny))
 
-In the [previous tutorial](tutorial-four-cl.md) we improved our
+In the [previous tutorial](tutorial-four-cl.html) we improved our
 logging system. Instead of using a `fanout` exchange only capable of
 dummy broadcasting, we used a `direct` one, and gained a possibility
 of selectively receiving the logs.
@@ -114,7 +116,7 @@ start off with a working assumption that the routing keys of logs will
 have two words: "`<facility>.<severity>`".
 
 The code is almost the same as in the
-[previous tutorial](tutorial-four-cl.md).
+[previous tutorial](tutorial-four-cl.html).
 
 The code for `emit_log_topic.lisp`:
 
@@ -178,4 +180,4 @@ with more than two routing key parameters.
 (Full source code for [emit_log_topic.lisp](code/emit_log_topic.lisp)
 and [receive_logs_topic.lisp](code/receive_logs_topic.lisp))
 
-Next, find out how to do a round trip message as a remote procedure call in [tutorial 6](tutorial-six-cl.md)
+Next, find out how to do a round trip message as a remote procedure call in [tutorial 6](tutorial-six-cl.html)

_includes/cl-bunny/tutorials/tutorial-four-cl.md

@@ -14,12 +14,14 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
+
 # RabbitMQ tutorial - Routing
 
 ## Routing
+
 ### (using [cl-bunny](http://cl-rabbit.io/cl-bunny))
 
-In the [previous tutorial](tutorial-three-cl.md) we built a
+In the [previous tutorial](tutorial-three-cl.html) we built a
 simple logging system. We were able to broadcast log messages to many
 receivers.
 
@@ -187,5 +189,5 @@ And, for example, to emit an `error` log message just type:
 (Full source code for [(emit_log_direct.lisp source)](code/emit_log_direct.lisp)
 and [(receive_logs_direct.lisp source)](code/receive_logs_direct.lisp))
 
-Move on to [tutorial 5](tutorial-five-cl.md) to find out how to listen
+Move on to [tutorial 5](tutorial-five-cl.html) to find out how to listen
 for messages based on a pattern.

_includes/cl-bunny/tutorials/tutorial-one-cl.md

@@ -47,7 +47,9 @@ RabbitMQ, and messaging in general, uses some jargon.
 Note that the producer, consumer, and  broker do not have to reside on
 the same machine; indeed in most applications they don't.
 
-## "Hello World" 
+
+## "Hello World"
+
 ### (using the cl-bunny Common Lisp Client) 
 
 In this part of the tutorial we'll write two small programs in Lisp; a
@@ -66,7 +68,7 @@ on behalf of the consumer.
 > RabbitMQ speaks AMQP 0.9.1, which is an open,
 > general-purpose protocol for messaging. There are a number of clients
 > for RabbitMQ in [many different
-> languages](/devtools.html). We'll
+> languages](http://www.rabbitmq.com/devtools.html). We'll
 > use the cl-bunny client in this tutorial.
 >
 > First, install cl-bunny using [official webpage](http://cl-rabbit.io/cl-bunny)
@@ -117,11 +119,11 @@ things done resides:
 To send, we must declare a queue for us to send to; then we can publish a message
 to the queue:
 
-  	(with-connection ("amqp://")
-  	  (with-channel ()
-  	    (let ((x (default-exchange)))
-  	      (publish x "Hello world!" :routing-key "hello")          
-  	      (format t " [x] Sent 'Hello World!'~%"))))
+    (with-connection ("amqp://")
+      (with-channel ()
+        (let ((x (default-exchange)))
+          (publish x "Hello world!" :routing-key "hello")          
+          (format t " [x] Sent 'Hello World!'~%"))))
 
 Declaring a queue is idempotent - it will only be created if it doesn't
 exist already. The message content is a byte array, so you can encode
@@ -177,15 +179,15 @@ queue. Since it will push us messages asynchronously, we provide a
 callback that will be executed when RabbitMQ pushes messages to
 our consumer. This is what `subscribe` does.
 
-  	(with-connection ("amqp://")
-  	  (with-channel ()
-  	    (let ((q (queue.declare "hello" :auto-delete t)))
-  	      (format t " [*] Waiting for messages in queue 'hello'. To exit type (exit)~%")
-  	      (subscribe q (lambda (message)
-  	                     (let ((body (babel:octets-to-string (message-body message))))
-  	                       (format t " [x] Received ~a~%" body)))
-  	                 :type :sync)
-  	      (consume :one-shot t))))
+    (with-connection ("amqp://")
+      (with-channel ()
+        (let ((q (queue.declare "hello" :auto-delete t)))
+          (format t " [*] Waiting for messages in queue 'hello'. To exit type (exit)~%")
+          (subscribe q (lambda (message)
+                         (let ((body (babel:octets-to-string (message-body message))))
+                           (format t " [x] Received ~a~%" body)))
+                     :type :sync)
+          (consume :one-shot t))))
 
 `subscribe` is used with the `:type :sync` option that makes it
 block the calling thread (we don't want the script to finish running immediately!).
@@ -210,4 +212,4 @@ If you want to check on the queue, try using `rabbitmqctl list_queues`.
 
 Hello World!
 
-Time to move on to [part 2](tutorial-two-cl.md) and build a simple _work queue_.
+Time to move on to [part 2](tutorial-two-cl.html) and build a simple _work queue_.

_includes/cl-bunny/tutorials/tutorial-six-cl.md

@@ -14,12 +14,14 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
+
 # RabbitMQ tutorial - Remote procedure call (RPC)
 
 ## Remote procedure call (RPC)
+
 ### (using [cl-bunny](http://cl-rabbit.io/cl-bunny))
 
-In the [second tutorial](tutorial-two-cl.md) we learned how to
+In the [second tutorial](tutorial-two-cl.html) we learned how to
 use _Work Queues_ to distribute time-consuming tasks among multiple
 workers.
 

_includes/cl-bunny/tutorials/tutorial-three-cl.md

@@ -14,12 +14,14 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
+
 # RabbitMQ tutorial - Publish/Subscribe
 
 ## Publish/Subscribe
+
 ### (using [cl-bunny](http://cl-rabbit.io/cl-bunny))
 
-In the [previous tutorial](tutorial-two-cl.md) we created a work
+In the [previous tutorial](tutorial-two-cl.html) we created a work
 queue. The assumption behind a work queue is that each task is
 delivered to exactly one worker. In this part we'll do something
 completely different -- we'll deliver a message to multiple
@@ -246,4 +248,4 @@ exchange `logs` goes to two queues with server-assigned names. And
 that's exactly what we intended.
 
 To find out how to listen for a subset of messages, let's move on to
-[tutorial 4](tutorial-four-cl.md)
+[tutorial 4](tutorial-four-cl.html)

_includes/cl-bunny/tutorials/tutorial-two-cl.md

@@ -14,14 +14,16 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
+
 # RabbitMQ tutorial - Work Queues
 
 ## Work Queues
+
 ### (using [cl-bunny](http://cl-rabbit.io/cl-bunny))
 
 ![](http://i.imgur.com/Tf7ltsH.png)
 
-In the [first tutorial](tutorial-one-cl.md) we
+In the [first tutorial](tutorial-one-cl.html) we
 wrote programs to send and receive messages from a named queue. In this
 one we'll create a _Work Queue_ that will be used to distribute
 time-consuming tasks among multiple workers.
@@ -323,5 +325,5 @@ RabbitMQ is restarted.
 For more information on functions and message properties, you can browse the
 [cl-bunny reference](http://cl-rabbit.io/cl-bunny/reference).
 
-Now we can move on to [tutorial 3](tutorial-three-cl.md) and learn how
+Now we can move on to [tutorial 3](tutorial-three-cl.html) and learn how
 to deliver the same message to many consumers.

_layouts/default.html

@@ -10,7 +10,8 @@
     <link rel="stylesheet" type="text/css" href="/style/style.css">
 
 
-    <link href='https://yastatic.net/highlightjs/8.2/styles/github.min.css' rel='stylesheet'>
+    <!-- <link href='https://yastatic.net/highlightjs/8.2/styles/github.min.css' rel='stylesheet'> -->
+    <link href='https://yastatic.net/highlightjs/8.2/styles/googlecode.min.css' rel='stylesheet'>
     <script src='https://yastatic.net/highlightjs/8.2/highlight.min.js'></script>
     <script src='https://yastatic.net/highlightjs/8.2/languages/lisp.min.js'></script>
 

cl-bunny/tutorials/code/emit_log_direct.lisp

@@ -0,0 +1,13 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(with-connection ("amqp://")
+  (with-channel ()
+    (let* ((args (cdr sb-ext:*posix-argv*))
+           (severity (if (car args) (car args) "info"))
+           (msg (format nil "~{~a ~}" (cdr args)))
+           (x (amqp-exchange-declare "direct_logs" :type "direct")))
+      (publish x msg :routing-key severity)
+      (format t " [x] Sent '~a'" msg)
+      (sleep 1))))

cl-bunny/tutorials/code/emit_log_topic.lisp

@@ -0,0 +1,13 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(with-connection ("amqp://")
+  (with-channel ()
+    (let* ((args (cdr sb-ext:*posix-argv*))
+           (severity (if (car args) (car args) "anonimous.info"))
+           (msg (format nil "~{~a ~}" (cdr args)))
+           (x (amqp-exchange-declare "topic_logs" :type "topic")))
+      (publish x msg :routing-key severity)
+      (format t " [x] Sent ~a:'~a'" severity msg)
+      (sleep 1))))

cl-bunny/tutorials/code/emit_logs.lisp

@@ -0,0 +1,11 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(with-connection ("amqp://")
+  (with-channel ()
+    (let ((msg (format nil "~{~a ~}" (cdr sb-ext:*posix-argv*)))
+          (x (amqp-exchange-declare "logs" :type "fanout")))
+      (publish x msg)
+      (format t " [x] Sent '~a'~%" msg)
+      (sleep 1))))

cl-bunny/tutorials/code/new_task.lisp

@@ -0,0 +1,12 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(with-connection ("amqp://")
+  (with-channel ()
+    (let ((x (default-exchange))
+          (msg (format nil "~{~a ~}" (cdr sb-ext:*posix-argv*))))
+      (publish x msg :routing-key "task_queue"
+                     :properties `((:persistent . ,t)))
+      (format t " [x] Sent '~a'~%" msg)
+      (sleep 1))))

cl-bunny/tutorials/code/receive.lisp

@@ -0,0 +1,13 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(with-connection ("amqp://")
+  (with-channel ()
+    (let ((q (queue.declare "hello" :auto-delete t)))
+      (format t " [*] Waiting for messages in queue 'hello'. To exit type (exit)~%")
+      (subscribe q (lambda (message)
+                     (let ((body (babel:octets-to-string (message-body message))))
+                       (format t " [x] Received ~a~%" body)))
+                 :type :sync)
+      (consume :one-shot t))))

cl-bunny/tutorials/code/receive_logs.lisp

@@ -0,0 +1,16 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(with-connection ("amqp://")
+  (with-channel ()
+    (let ((n 1)
+          (x (amqp-exchange-declare "logs" :type "fanout"))
+          (q (queue.declare "" :auto-delete t)))
+      (amqp-queue-bind q :exchange x)
+      (format t " [*] Waiting for logs. To exit type (exit)~%")
+      (subscribe q (lambda (message)
+                     (let ((body (babel:octets-to-string (message-body message))))
+                       (format t " [x] #~a~%" body)))
+                 :type :sync)
+      (consume))))

cl-bunny/tutorials/code/receive_logs_direct.lisp

@@ -0,0 +1,19 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(let ((args (cdr sb-ext:*posix-argv*)))
+  (if args
+      (with-connection ("amqp://")
+        (with-channel ()
+          (let ((args (cdr sb-ext:*posix-argv*))
+                (q (queue.declare "" :auto-delete t)))
+            (loop for severity in args do
+                     (amqp-queue-bind q :exchange "direct_logs" :routing-key severity))
+            (format t " [*] Waiting for logs. To exit type (exit)~%")
+            (subscribe q (lambda (message)
+                           (let ((body (babel:octets-to-string (message-body message))))
+                             (format t " [x] #~a~%" body)))
+                       :type :sync)
+            (consume))))
+      (error "Usage: #{$0} [info] [warning] [error]")))

cl-bunny/tutorials/code/receive_logs_topic.lisp

@@ -0,0 +1,19 @@
+(ql:quickload :cl-bunny.examples)
+
+(in-package :cl-bunny.examples)
+
+(let ((args (cdr sb-ext:*posix-argv*)))
+  (if args
+      (with-connection ("amqp://")
+        (with-channel ()
+          (let ((args (cdr sb-ext:*posix-argv*))
+                (q (queue.declare "" :auto-delete t)))
+            (loop for severity in args do
+                     (amqp-queue-bind q :exchange "topic_logs" :routing-key severity))
+            (format t " [*] Waiting for logs. To exit type (exit)~%")
+            (subscribe q (lambda (message)
+                           (let ((body (babel:octets-to-string (message-body message))))
+                             (format t " [x] #~a~%" body)))
+                       :type :sync)
+            (consume))))
+      (error "Usage: #{$0} [binding key]")))

cl-bunny/tutorials/code/rpc_client.lisp

@@ -0,0 +1,49 @@
+(ql:quickload :cl-bunny.examples)
+(ql:quickload :nibbles)
+
+(in-package :cl-bunny.examples)
+
+(defun int32-to-octet(val)
+  (declare (type (signed-byte 32) val)
+           (optimize (sb-c::insert-debug-catch 0)  
+                     (speed 3) 
+                     (compilation-speed 0)
+                     (safety 0)))
+  (let ((array (make-array 4 :element-type '(unsigned-byte 8))))
+    (setf (aref array 0) (ldb (byte 8 0) val))
+    (setf (aref array 1) (ldb (byte 8 8) val))
+    (setf (aref array 2) (ldb (byte 8 16) val))
+    (setf (aref array 3) (ldb (byte 8 24) val))
+    array))
+
+(defun start-client (n)
+  (with-connection ("amqp://")
+    (with-channel ()
+      (let ((x (default-exchange))
+            (server-queue "rpc_queue")
+            (reply-queue (queue.declare "" :auto-delete t))
+            (lock (bt:make-lock))
+            (condition (bt:make-condition-variable))
+            (result nil))
+        (format t " [x] Requesting fib(~a)~%" n)
+        (bt:with-lock-held (lock)
+          (subscribe reply-queue (lambda (message)
+                                   (bt:with-lock-held (lock)
+                                     (setf result (nibbles:sb32ref/le (coerce (message-body message) '(vector (unsigned-byte 8))) 0))
+                                     (bt:condition-notify condition))))
+          (publish x
+                   (int32-to-octet n)
+                   :routing-key server-queue
+                   :properties `((:correlation-id . ,(format nil "~a~a~a" (random 100) (random 100) (random 100)))
+                                 (:reply-to . ,reply-queue)))
+          (bt:condition-wait condition lock)
+          (format t " [.] Got ~a~%" result)
+          result)))))
+
+(start-client 0)
+(start-client 1)
+(start-client 2)
+(start-client 3)
+(start-client 4)
+(start-client 5)
+