alchemy-flux 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5820f4295838010b3f94ee73e729657d22cced0f
-  data.tar.gz: 040f7690b3b91f7b86915dc77973014d3a58c304
+  metadata.gz: 79536f814a7c62f09925bf33d0ba8f5faaff4d72
+  data.tar.gz: c165d0e7b4023b3199bac181896c0b796a5e7fa7
 SHA512:
-  metadata.gz: ca7a76d755a04790abc72273ca044df9f65bb08b103e0a3ba1e7b68b4491e1035ee37bc77b573c8d488821af800c2bbe73f8f718449021fc13d8c7fb67ac8297
-  data.tar.gz: 74d842ddead3cae1cdfa6ad663efd2db3c352d1cb4a2bfb1c4cedcc4eae1590d09f26a1ab7fe5595f6fd3c11d282881a608d0c31a4fe490627292c8767f54a69
+  metadata.gz: a55a9a147d17e23b32db10217a94816aada57385c0d86ebc02c70cf42d87f466726593e4919585669289401ffc92ffa2093e0748023b8621b989bedd9af68f7f
+  data.tar.gz: 628d1735463517bcb0f112c695e7461af86d95e6d152e5fd79c3f9b0b69cd8d1e06c674fc48e40ef0040fe17424e6c8f7623e8f20b0e4f9ffb3db0ab59c0a8cf

data/lib/alchemy-flux.rb

@@ -1,7 +1,7 @@
 require 'time'
 require 'amqp'
 require "uuidtools"
-require 'msgpack'
+require 'json'
 
 require 'alchemy-flux/flux_rack_handler.rb'
 
@@ -140,25 +140,25 @@ module AlchemyFlux
 
         @service_queue = @channel.queue( @service_queue_name, {:durable => true})
         @service_queue.subscribe({:ack => true}) do |metadata, payload|
-          payload = MessagePack.unpack(payload)
+          payload = JSON.parse(payload)
           process_service_queue_message(metadata, payload)
         end
 
         response_queue = @channel.queue(@response_queue_name, {:exclusive => true, :auto_delete => true})
         response_queue.subscribe({}) do |metadata, payload|
-          payload = MessagePack.unpack(payload)
+          payload = JSON.parse(payload)
           process_response_queue_message(metadata, payload)
         end
 
         @channel.default_exchange.on_return do |basic_return, frame, payload|
-          payload = MessagePack.unpack(payload)
+          payload = JSON.parse(payload)
           process_returned_message(basic_return, frame.properties, payload)
         end
 
         # RESOURCES HANDLE
         @resources_exchange = @channel.topic("resources.exchange", {:durable => true})
         @resources_exchange.on_return do |basic_return, frame, payload|
-          payload = MessagePack.unpack(payload)
+          payload = JSON.parse(payload)
           process_returned_message(basic_return, frame.properties, payload)
         end
 
@@ -229,7 +229,6 @@ module AlchemyFlux
         rescue Exception => e
           puts "Service Fn Error " + e.inspect
 
-          # Returning Hoodoo formatted Error code (just in case service doesnt handle the error, it should!)
           {
             'status_code' => 500,
             'headers' => {'Content-Type' => 'application/json; charset=utf-8'},
@@ -237,7 +236,11 @@ module AlchemyFlux
               'kind' =>           "Errors",
               'id' =>             AlchemyFlux::Service.generateUUID(),
               'created_at' =>     Time.now.utc.iso8601,
-              'errors' => [{'code' => 'platform.fault', 'message' => 'An unexpected error occurred'}]
+              'errors' => [{
+                'code' => 'alchemy-flux.error',
+                'message' => 'An unexpected error occurred',
+                'message_id' => message_replying_to
+              }]
             }
           }
         end
@@ -248,12 +251,16 @@ module AlchemyFlux
         if result == AlchemyFlux::NAckError
           @service_queue.reject(delivery_tag)
         else
-          options = {
-            :message_id     => this_message_id,
-            :correlation_id => message_replying_to,
-            :type           =>    'http_response'
-          }
-          send_message(@channel.default_exchange, service_to_reply_to, result, options)
+          #if there is a service to reply to then reply, else ignore
+
+          if service_to_reply_to
+            send_message(@channel.default_exchange, service_to_reply_to, result, {
+              :message_id     => this_message_id,
+              :correlation_id => message_replying_to,
+              :type           =>    'http_response'
+            })
+          end
+
           @processing_messages -= 1
           @service_queue.acknowledge(delivery_tag)
         end
@@ -294,7 +301,7 @@ module AlchemyFlux
     # *options*:: The message options
     def send_message(exchange, routing_key, message, options)
       message_options = options.merge({:routing_key => routing_key})
-      message = MessagePack.pack(message)
+      message = message.to_json
       EventMachine.next_tick do
         exchange.publish message, message_options
       end
@@ -302,44 +309,51 @@ module AlchemyFlux
 
     public
 
-    # send a message to queue do not wait for response
+    # send a message to a service, this does not wait for a response
     #
-    # *routing_key*:: The routing key to use
+    # *service_name*:: The name of the service
     # *message*:: The message to be sent
-    # *options*:: The message options
-    def send_message_to_queue(routing_key, message)
-      send_message( @channel.default_exchange, routing_key, message, {type: 'ignore'} )
+    def send_message_to_service(service_name, message)
+      send_HTTP_message(@channel.default_exchange, service_name, message)
     end
 
-    # send a message to a service
+    # send a message to a resource, this does not wait for a response
+    #
+    # *message*:: HTTP formatted message to be sent, must contain `'path'` key with URL path
+    def send_message_to_resource(message)
+      routing_key = path_to_routing_key(message['path'])
+      send_HTTP_message(@resources_exchange, routing_key, message)
+    end
+
+    # send a request to a service, this will wait for a response
     #
     # *service_name*:: the name of the service
     # *message*:: the message to be sent
     #
     # This method can optionally take a block which will be executed asynchronously and yielded the response
-    def send_message_to_service(service_name, message)
+    def send_request_to_service(service_name, message)
       if block_given?
         EventMachine.defer do
-          yield send_message_to_service(service_name, message)
+          yield send_request_to_service(service_name, message)
         end
       else
-        send_HTTP_request_message(@channel.default_exchange, service_name, message)
+        send_HTTP_request(@channel.default_exchange, service_name, message)
       end
     end
 
     # send a message to a resource
     #
-    # *http_message*:: the message to be sent to the *path* in the message
+    # *message*:: HTTP formatted message to be sent, must contain `'path'` key with URL path
     #
     # This method can optionally take a block which will be executed asynchronously and yielded the response
-    def send_message_to_resource(http_message)
-      routing_key = path_to_routing_key(http_message['path'])
+    def send_request_to_resource(message)
+      routing_key = path_to_routing_key(message['path'])
       if block_given?
         EventMachine.defer do
-          yield send_message_to_resource(http_message)
+          yield send_request_to_resource(message)
         end
       else
-        send_HTTP_request_message(@resources_exchange, routing_key, http_message)
+        send_HTTP_request(@resources_exchange, routing_key, message)
       end
     end
 
@@ -363,35 +377,90 @@ module AlchemyFlux
       new_path
     end
 
+    # format the HTTP message
+    #
+    # The entire body is a JSON string with the keys:
+    #
+    # Request Information:
+    #
+    # 1. *body*: A string of body information
+    # 2. *verb*: The HTTP verb for the query, e.g. GET
+    # 3. *headers*: an object with headers in is, e.g. {"X-HEADER-KEY": "value"}
+    # 4. *path*: the path of the request, e.g. "/v1/users/1337"
+    # 5. *query*: an object with keys for query, e.g. {'search': 'flux'}
+    #
+    # Call information:
+    #
+    # 1. *scheme*: the scheme used for the call
+    # 2. *host*: the host called to make the call
+    # 3. *port*: the port the call was made on
+    #
+    # Authentication information:
+    #
+    # 1. *session*: undefined structure that can be passed in the message
+    # so that a service does not need to re-authenticate with each message
+    #
+    def format_HTTP_message(message)
+      message = {
+        # Request Parameters
+        'body' =>        message['body']        || "",
+        'verb' =>        message['verb']        || "GET",
+        'headers' =>     message['headers']     || {},
+        'path' =>        message['path']        || "/",
+        'query' =>       message['query']       || {},
+
+        # Location
+        'scheme' =>      message['protocol']    || 'http',
+        'host' =>        message['hostname']    || 'localhost',
+        'port' =>        message['port']        || 8080,
+
+        # Custom Authentication
+        'session'    =>  message['session']
+      }
+
+      message
+    end
+
     # send a HTTP message to an exchange with routing key
     #
     # *exchange*:: A AMQP exchange
     # *routing_key*:: The routing key to use
     # *message*:: The message to be sent
-    def send_HTTP_request_message(exchange, routing_key, message)
+    def send_HTTP_message(exchange, routing_key, message)
+      http_message = format_HTTP_message(message)
 
-      http_message = {
-        'session_id' =>  message['session_id'],
-        'scheme' =>      message['protocol']    || 'http',
-        'host' =>        message['hostname']    || 'localhost',
-        'port' =>        message['port']        || 8080,
-        'path' =>        message['path']        || "/",
-        'query' =>       message['query']       || {},
-        'verb' =>        message['verb']        || "GET",
-        'headers' =>     message['headers']     || {},
-        'body' =>        message['body']        || ""
+      http_message_options = {
+        message_id:          AlchemyFlux::Service.generateUUID(),
+        type:               'http',
+        content_encoding:   '8bit',
+        content_type:       'application/json',
+        expiration:          @options[:timeout],
+        mandatory:           true
       }
 
+      send_message(exchange, routing_key, http_message, http_message_options)
+    end
+
+
+
+    # send a HTTP message to an exchange with routing key
+    #
+    # *exchange*:: A AMQP exchange
+    # *routing_key*:: The routing key to use
+    # *message*:: The message to be sent
+    def send_HTTP_request(exchange, routing_key, message)
+      http_message = format_HTTP_message(message)
+
       message_id = AlchemyFlux::Service.generateUUID()
 
       http_message_options = {
         message_id:          message_id,
-        type:               'http_request',
+        type:               'http',
         reply_to:            @response_queue_name,
-        content_encoding:    '8bit',
-        content_type:        'application/octet-stream',
-        expiration:           @options[:timeout],
-        mandatory:            true
+        content_encoding:   '8bit',
+        content_type:       'application/json',
+        expiration:          @options[:timeout],
+        mandatory:           true
       }
 
       response_queue = Queue.new

data/lib/alchemy-flux/flux_rack_handler.rb

@@ -55,6 +55,7 @@ module Rack
 
           # add Alchemy Service so the app may call other services
           rack_env['alchemy.service'] = @@service
+          rack_env['alchemy.session'] = message['session']
 
           status, headers, body = app.call(rack_env)
 

data/spec/performance_spec.rb

@@ -22,7 +22,7 @@ describe "performance of AlchemyFlux" do
     responses = Queue.new
     st = Time.now()
     (1..calls).each do
-      service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}}) do |response|
+      service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}}) do |response|
         responses << response
       end
     end
@@ -51,7 +51,7 @@ describe "performance of AlchemyFlux" do
 
     st = Time.now()
     (1..calls).each do
-      resp = service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
+      resp = service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
       expect(resp['body']).to eq "hola Bob"
     end
 

data/spec/rack_handler_spec.rb

@@ -19,7 +19,7 @@ describe Rack::Handler::AlchemyFlux do
       Rack::Handler::AlchemyFlux.start app
       service_a.start
       sleep(0.5)
-      response = service_a.send_message_to_service("rack.service", {})
+      response = service_a.send_request_to_service("rack.service", {})
       expect(response['body']).to eq "hi Bob"
       service_a.stop
       Rack::Handler::AlchemyFlux.stop
@@ -38,10 +38,10 @@ describe Rack::Handler::AlchemyFlux do
       service_a.start
       sleep(0.5)
 
-      response = service_a.send_message_to_resource({'path' => '/alice'})
+      response = service_a.send_request_to_resource({'path' => '/alice'})
       expect(response['body']).to eq "hi /alice"
 
-      response = service_a.send_message_to_resource({'path' => '/bob'})
+      response = service_a.send_request_to_resource({'path' => '/bob'})
       expect(response['body']).to eq "hi /bob"
 
       service_a.stop

data/spec/resources_spec.rb

@@ -7,7 +7,7 @@ describe AlchemyFlux::Service do
     AlchemyFlux::Service.stop
   end
 
-  describe "#send_message_to_resource" do
+  describe "#send_request_to_resource" do
 
     it 'should be able to send messages to resource via path' do
       resource_path = "/v1/fluxy_#{AlchemyFlux::Service.generateUUID()}"
@@ -22,10 +22,10 @@ describe AlchemyFlux::Service do
 
       sleep(1)
 
-      response = service_b.send_message_to_resource({'path' => resource_path, 'body' => {'name' => "Bob"}})
+      response = service_b.send_request_to_resource({'path' => resource_path, 'body' => {'name' => "Bob"}})
       expect(response['body']).to eq "hi Bob"
 
-      response = service_b.send_message_to_resource({'path' => "#{resource_path}/id", 'body' => {'name' => "Alice"}})
+      response = service_b.send_request_to_resource({'path' => "#{resource_path}/id", 'body' => {'name' => "Alice"}})
       expect(response['body']).to eq "hi Alice"
 
       service_a.stop
@@ -46,10 +46,10 @@ describe AlchemyFlux::Service do
 
       sleep(1)
 
-      response = service_b.send_message_to_resource({'path' => resource_path1, 'body' => {'name' => "Bob"}})
+      response = service_b.send_request_to_resource({'path' => resource_path1, 'body' => {'name' => "Bob"}})
       expect(response['body']).to eq "hi Bob"
 
-      response = service_b.send_message_to_resource({'path' => resource_path2, 'body' => {'name' => "Alice"}})
+      response = service_b.send_request_to_resource({'path' => resource_path2, 'body' => {'name' => "Alice"}})
       expect(response['body']).to eq "hi Alice"
       service_a.stop
       service_b.stop
@@ -62,7 +62,7 @@ describe AlchemyFlux::Service do
 
         service_b.start
 
-        expect(service_b.send_message_to_resource({'path' => '/v1/unregistered_resource'})).to eq AlchemyFlux::MessageNotDeliveredError
+        expect(service_b.send_request_to_resource({'path' => '/v1/unregistered_resource'})).to eq AlchemyFlux::MessageNotDeliveredError
         expect(service_b.transactions.length).to eq 0
 
         service_b.stop
@@ -70,4 +70,33 @@ describe AlchemyFlux::Service do
 
     end
   end
+
+  describe "#send_message_to_resource" do
+    it 'should be able to send messages to resource via path' do
+      resource_path = "/v1/fluxy_#{AlchemyFlux::Service.generateUUID()}"
+      recieved_count = 0
+      service_a = AlchemyFlux::Service.new("fluxa.send_service", resource_paths: [resource_path]) do |message|
+        recieved_count += 1
+        {}
+      end
+
+      service_b = AlchemyFlux::Service.new("fluxb.send_service")
+
+      service_a.start
+      service_b.start
+
+      sleep(1)
+      expect(recieved_count).to be 0
+      response = service_b.send_request_to_resource({'path' => resource_path, 'body' => {'name' => "Bob"}})
+      sleep(0.1)
+      expect(recieved_count).to be 1
+      response = service_b.send_request_to_resource({'path' => "#{resource_path}/id", 'body' => {'name' => "Alice"}})
+      sleep(0.1)
+      expect(recieved_count).to be 2
+
+      service_a.stop
+      service_b.stop
+    end
+
+  end
 end

data/spec/service_spec.rb

@@ -92,7 +92,7 @@ describe AlchemyFlux::Service do
       service_b.start
 
       service_a.stop
-      expect(service_b.send_message_to_service("fluxa.service", {})).to eq AlchemyFlux::TimeoutError
+      expect(service_b.send_request_to_service("fluxa.service", {})).to eq AlchemyFlux::TimeoutError
       service_b.stop
     end
 
@@ -108,7 +108,7 @@ describe AlchemyFlux::Service do
       service_b.start
 
       response_queue = Queue.new
-      service_b.send_message_to_service("fluxa.service", {}) do |response|
+      service_b.send_request_to_service("fluxa.service", {}) do |response|
         response_queue << response
       end
       sleep(0.05)
@@ -132,7 +132,7 @@ describe AlchemyFlux::Service do
       service_b.start
 
       response_queue = Queue.new
-      service_b.send_message_to_service("fluxa.service", {}) do |response|
+      service_b.send_request_to_service("fluxa.service", {}) do |response|
         response_queue << response
       end
       sleep(0.01)
@@ -156,13 +156,13 @@ describe AlchemyFlux::Service do
       service_b.start
 
       response_queue = Queue.new
-      service_b.send_message_to_service("fluxa.service", {}) do |response|
+      service_b.send_request_to_service("fluxa.service", {}) do |response|
         response_queue << response
       end
       sleep(0.1)
       Thread.new do service_a.stop end
       sleep(0.3)
-      expect(service_b.send_message_to_service("fluxa.service", {})).to eq AlchemyFlux::TimeoutError
+      expect(service_b.send_request_to_service("fluxa.service", {})).to eq AlchemyFlux::TimeoutError
 
       response = response_queue.pop
 
@@ -180,10 +180,10 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
+      response = service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
       expect(response['body']).to eq "hi Bob"
 
-      response = service_a.send_message_to_service("fluxb.service", {'body' => {'name' => "Bob"}})
+      response = service_a.send_request_to_service("fluxb.service", {'body' => {'name' => "Bob"}})
       expect(response['body']).to be_empty
 
 
@@ -192,7 +192,8 @@ describe AlchemyFlux::Service do
     end
   end
 
-  describe "#send_message_to_queue" do
+
+  describe "#send_message_to_service" do
     it 'should send a message to services' do
       received = false
       service_a = AlchemyFlux::Service.new("fluxa.service") do |message|
@@ -205,7 +206,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_queue("fluxa.service", {})
+      service_b.send_message_to_service("fluxa.service", {})
       sleep(0.1)
       expect(received).to be true
       service_a.stop
@@ -214,7 +215,9 @@ describe AlchemyFlux::Service do
 
   end
 
-  describe "#send_message_to_service" do
+
+
+  describe "#send_request_to_service" do
 
     it 'should send and receive messages between services' do
       service_a = AlchemyFlux::Service.new("fluxa.service") do |message|
@@ -226,7 +229,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
+      response = service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
       expect(response['body']).to eq "hi Bob"
       service_a.stop
       service_b.stop
@@ -244,7 +247,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {'body' => '{"name" : "Bob"}'})
+      response = service_b.send_request_to_service("fluxa.service", {'body' => '{"name" : "Bob"}'})
       expect(response['body']).to eq "hi Bob"
       service_a.stop
       service_b.stop
@@ -264,7 +267,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {'body' => '{"name" : "Bob"}'})
+      response = service_b.send_request_to_service("fluxa.service", {'body' => '{"name" : "Bob"}'})
       expect(response['body']).to eq "hi Bob"
       expect(response['headers']["X-header"]).to eq "header1"
       service_a.stop
@@ -285,7 +288,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {'body' => '{"name" : "Bob"}'})
+      response = service_b.send_request_to_service("fluxa.service", {'body' => '{"name" : "Bob"}'})
       expect(response['body']).to eq "hi Bob"
       expect(response['status_code']).to eq 201
       service_a.stop
@@ -294,7 +297,7 @@ describe AlchemyFlux::Service do
 
     it 'should be able to send messages within the service call' do
       service_a = AlchemyFlux::Service.new("fluxa.service") do |message|
-        resp = service_a.send_message_to_service("fluxb.service", {})
+        resp = service_a.send_request_to_service("fluxb.service", {})
         {'body' => "hi #{resp['body']}"}
       end
 
@@ -305,7 +308,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {})
+      response = service_b.send_request_to_service("fluxa.service", {})
       expect(response['body']).to eq "hi Bob"
       service_a.stop
       service_b.stop
@@ -316,7 +319,7 @@ describe AlchemyFlux::Service do
       service_a = AlchemyFlux::Service.new("fluxa.service") do |message|
         if first
           first = !first
-          resp = service_a.send_message_to_service("fluxa.service", {})
+          resp = service_a.send_request_to_service("fluxa.service", {})
           {'body' => "hi #{resp['body']}"}
         else
           {'body' => 'Bob'}
@@ -328,7 +331,7 @@ describe AlchemyFlux::Service do
       service_a.start
       service_b.start
 
-      response = service_b.send_message_to_service("fluxa.service", {})
+      response = service_b.send_request_to_service("fluxa.service", {})
       expect(response['body']).to eq "hi Bob"
       service_a.stop
       service_b.stop
@@ -351,7 +354,7 @@ describe AlchemyFlux::Service do
       expect(service_a.processing_messages).to eq 0
 
       response = Queue.new
-      service_b.send_message_to_service("fluxa.service", {}) do |resp|
+      service_b.send_request_to_service("fluxa.service", {}) do |resp|
         response << resp
       end
       sleep(0.05)
@@ -378,7 +381,7 @@ describe AlchemyFlux::Service do
       service_b.start
 
       block = Queue.new
-      service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}}) do |response|
+      service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}}) do |response|
         block << response
       end
 
@@ -404,7 +407,7 @@ describe AlchemyFlux::Service do
         service_b.start
 
         block = Queue.new
-        service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}}) do |response|
+        service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}}) do |response|
           block << response
         end
         response = block.pop
@@ -425,7 +428,7 @@ describe AlchemyFlux::Service do
         service_a.start
         service_b.start
 
-        response = service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
+        response = service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
 
         expect(response).to eq AlchemyFlux::TimeoutError
         expect(service_b.transactions.length).to eq 0
@@ -444,7 +447,7 @@ describe AlchemyFlux::Service do
         service_a.start
         service_b.start
 
-        response = service_b.send_message_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
+        response = service_b.send_request_to_service("fluxa.service", {'body' => {'name' => "Bob"}})
 
         expect(response['status_code']).to eq 500
         expect(service_b.transactions.length).to eq 0
@@ -458,7 +461,7 @@ describe AlchemyFlux::Service do
 
         service_b.start
 
-        expect(service_b.send_message_to_service("not_a_servoces.service", {})).to eq AlchemyFlux::MessageNotDeliveredError
+        expect(service_b.send_request_to_service("not_a_servoces.service", {})).to eq AlchemyFlux::MessageNotDeliveredError
         expect(service_b.transactions.length).to eq 0
 
         service_b.stop

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alchemy-flux
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -122,20 +122,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
-- !ruby/object:Gem::Dependency
-  name: msgpack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.7'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.7'
 description: Ruby implementation of the Alchemy micro-service framework
 email:
 - graham.jenson@loyalty.co.nz
@@ -170,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of the Alchemy micro-service framework