skydb 0.2.3 → 0.3.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTYyYTgwMmM5YTIxMzdjNzk0YjhkNTc5ZmQ1NWIyODcwOTkyOGNmZA==
+  data.tar.gz: !binary |-
+    NjdmZWY1NDMxNGQ3OTJmNzk0MTMxMjIwMWRkMDczYTg1ZDQ0MTZiMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZjE4MGM3NDJkMDU4ODEzOGYzMzVmZDkwZTVhODNkNDA5NGQzYzRhNjk2YWQ5
+    MDNmZmVjODg3NjdlNmE3MGU2YTE0NWY2ODgwZWE3OGZmMTY4NDY4YTI3OGEx
+    MjVkZGI2YjM0YmZmOTMzM2U3ZmI3NTZiNWUzOWNiYmY0MTQ1MWE=
+  data.tar.gz: !binary |-
+    MWI2NTU4ZTRlYzg3ZTI1OWI4MThlYTY1NTdmZWQ4NWFmYjlmZTQxYjJkYzQ0
+    ZGQ3MGM4NGRjNjc1MTlkODMzMzFjNjZiNGU0ZGFmYzYxMjQxMjI4MmE4MjFj
+    YzEwZGQwMDI3ODQyNmJkNzc3MWU4ZTA4MjFlODQ2ZGVhMDk3MTA=

data/README.md

@@ -1,4 +1,168 @@
 sky.rb
 ======
 
-The Ruby client for the Sky database.
+## Overview
+
+The official Ruby client for the [Sky database](http://skydb.io).
+This client provides a simple wrapper around the Sky HTTP-based API.
+
+
+## API
+
+### The Basics
+
+To connect to your Sky database, simply create a client pointing to the appropriate host and port.
+The client will default to `localhost:8585` unless otherwise specified.
+
+```ruby
+require "skydb"
+client = SkyDB::Client.new(:host => 'localhost', :port => 8585)
+```
+
+### Table API
+
+The table API allows you to retrieve table information, create tables and delete tables.
+
+```ruby
+require "skydb"
+client = SkyDB::Client.new()
+
+# Retrieve a list of all tables.
+tables = client.get_tables()
+
+# Retrieve data about a single table.
+table = client.get_table()
+
+# Create a new table named 'foo'.
+table = client.create_table(:name => 'foo')
+
+# Delete the 'foo' table.
+client.delete_table(table)
+```
+
+
+### Property API
+
+The property API allows you to retrieve property information, create properties, update properties and delete properties from a table.
+
+There are five data types in Sky: `string`, `integer`, `float`, `boolean` and `factor`.
+The first four are self-explanatory.
+The `factor` data type acts like a `string` but internally it is represented as an integer with a lookup to the original string value.
+This type should be used when you have categorical data such as gender, country or any property that has a limited number of possible values.
+
+In addition to data types, Sky properties can also be transient or permanent.
+A transient property means that the value of the property exists only for a single moment in time.
+Typically this would be used for data related to a specific event such as the purchase amount of a checkout on a web site.
+A permanent property means that the value of the property stays in effect until changed.
+An example of this would be a user's gender or their household income.
+
+```ruby
+require "skydb"
+client = SkyDB::Client.new()
+table = client.get_table(:name => 'foo')
+
+# Retrieve a list of all properties on the table.
+properties = table.get_properties()
+
+# Retrieve a single property from the table.
+property = table.get_property()
+
+# Create a new transient, integer property named 'purchase_amount'.
+property = table.create_property(:name => 'purchase_amount', :transient => true, :data_type => 'integer')
+
+# Update the 'purchase_amount' property to be named 'total_purchase_amount'.
+# Note that only the name change be changed on a property -- not it's transiency or data type.
+property.name = 'total_purchase_amount'
+table.update_property(property)
+
+# Delete the property.
+table.delete_property(property)
+```
+
+### Event API
+
+The event API allows you to add events to objects on a table.
+In Sky, objects are simply a sum of their events so objects do not need to be created explicitly.
+Simply add events using an object key (e.g. a user id, e-mail address, or some other uniquely identifying string).
+
+When adding events to the database, Sky will automatically deduplicate permanent values.
+For example, if you set an object's "gender" property to "male" at Jan 1st 2000 at 1pm and then set it to "male" again on Jan 1st 2000 at 2pm then Sky will remove the second gender value since it can be determined by the first event.
+
+Sky will also merge a events if adding an event that already exists at the same time for a given object.
+This is typically unlikely as Sky's time resolution is one microsecond.
+
+```ruby
+require "skydb"
+client = SkyDB::Client.new()
+table = client.get_table(:name => 'foo')
+table.create_property(:name => "action", :transient => true, :data_type => "factor")
+table.create_property(:name => "purchase_amount", :transient => true, :data_type => "float")
+table.create_property(:name => "full_name", :data_type => "string")
+
+# Retrieve a list of all events for an object.
+events = table.get_events("susy")
+
+# Retrieve the event that occurs at a given moment for an object.
+event = table.get_event("susy", DateTime.iso8601('2000-01-01T00:00:00Z'))
+
+# Add a new event for an object (and merge with an existing event).
+table.add_event("susy", :timestamp => DateTime.iso8601('2000-01-01T00:00:00Z'), :data => {"action" => "checekout", "purchase_amount" => 100, "full_name" => "Susy Que"})
+
+# Add a new event for an object (and replace an existing event).
+table.add_event("susy", {:timestamp => DateTime.iso8601('2000-01-01T00:00:00Z'), :data => {"action" => "checekout", "purchase_amount" => 100, "full_name" => "Susy Que"}}, :method => :replace)
+
+# Delete an event at the given moment.
+table.delete_event("susy", :timestamp => DateTime.iso8601('2000-01-01T00:00:00Z'))
+```
+
+### Query API
+
+Once your event data is in Sky, you can quickly iterate over it and query it for information.
+There are two primitives in the Sky query system: conditions & selections.
+Conditions allow you to execute nested conditions or selections if its expression evaluates to true.
+Selections allow you to actually retrieve the data from the current event and group it by multiple dimensions.
+
+For a full explanation of the Sky query system, please visit the [Sky web site](http://skydb.io).
+
+```ruby
+require "skydb"
+client = SkyDB::Client.new()
+table = client.get_table(:name => 'users')
+table.create_property(:name => "action", :transient => true, :data_type => "factor")
+table.create_property(:name => "purchase_amount", :transient => true, :data_type => "float")
+table.create_property(:name => "gender", :data_type => "factor")
+table.create_property(:name => "state", :data_type => "factor")
+
+# Perform a simple count of all events in the table.
+results = client.query([:type => 'selection', :fields => [{:name => 'myCount', :expression => 'count()'}]])
+
+# Count the number of users that performed the actions 'view home page', 'sign up' and then 'checkout' within a session
+# and group the results by gender and state.
+results = client.query(
+  :sessionIdleTime => 7200,
+  :steps => [
+    {:type => 'condition', :expression => 'action == "view home page"', :steps => [
+      {:type => 'condition', :expression => 'action == "sign up"', :within => [1,1], :steps => [
+        {:type => 'condition', :expression => 'checkout', :within => [1,1], :steps => [
+          {:type => 'selection', :dimensions => ['gender', 'state'], :fields => [
+            {:name => 'count', :expression => 'count()'},
+            {:name => 'total_amount', :expression => 'sum(purchase_amount)'}
+          ]},
+        ]}
+      ]}
+    ]}
+  ]
+)
+#=> {'gender' => {'m' => {'state' => {'CA' => {'count' => 10, 'total_amount' => 291.93}}}}
+```
+
+### Utility API
+
+To check if the server is up and running, you can use the `ping` command:
+
+
+```ruby
+require "skydb"
+client = SkyDB::Client.new()
+is_running = client.ping()
+```

data/lib/skydb.rb

@@ -1,23 +1,7 @@
 require 'date'
-require 'msgpack'
-require 'socket'
-require 'treetop'
+require 'net/http'
 require 'json'
 
-require 'skydb/action'
-require 'skydb/client'
-require 'skydb/event'
-require 'skydb/message'
-require 'skydb/property'
-require 'skydb/query'
-require 'skydb/table'
-require 'skydb/timestamp'
-require 'skydb/version'
-
-require 'ext/hash'
-require 'ext/string'
-require 'ext/treetop'
-
 class SkyDB
   ############################################################################
   #
@@ -25,31 +9,8 @@ class SkyDB
   #
   ############################################################################
 
-  class TableRequiredError < StandardError; end
-
-  class ObjectIdRequiredError < StandardError; end
-  class TimestampRequiredError < StandardError; end
+  class SkyError < StandardError; end
 
-  ############################################################################
-  #
-  # Constants
-  #
-  ############################################################################
-
-  CLIENT_PASSTHROUGH = [
-    :host, :host=, :port, :port=,
-    :table_name, :table_name=,
-    :multi, :ping, :lookup,
-    :add_event,
-    :create_table, :delete_table, :get_table, :get_tables,
-    :add_action, :get_action, :get_actions,
-    :add_property, :get_property, :get_properties,
-    :next_actions,
-    :aggregate,
-    :query, :select
-  ]
-  
-  
   ############################################################################
   #
   # Static Attributes
@@ -64,20 +25,6 @@ class SkyDB
     attr_accessor :debug
   end
 
-  ######################################
-  # Default Client
-  ######################################
-  
-  # The default Sky client.
-  def self.client
-    @client ||= SkyDB::Client.new()
-    return @client
-  end
-
-  def self.client=(value)
-    @client = value
-  end
-  
 
   ############################################################################
   #
@@ -85,12 +32,22 @@ class SkyDB
   #
   ############################################################################
 
-  def self.method_missing(method, *args, &block)
-    method = method
-    if CLIENT_PASSTHROUGH.include?(method.to_sym)
-      client.__send__(method.to_sym, *args, &block)
+  ######################################
+  # Timestamps
+  ######################################
+  
+  # Formats a timestamp as ISO8601 formatted string with fractional seconds.
+  def self.format_timestamp(timestamp)
+    if timestamp.nil?
+      return nil
     else
-      raise NoMethodError.new("Message type not available: #{method}")
+      return timestamp.to_time.utc.to_datetime.strftime('%Y-%m-%dT%H:%M:%S.%6NZ')
     end
   end
-end
+end
+
+require 'skydb/client'
+require 'skydb/table'
+require 'skydb/property'
+require 'skydb/event'
+require 'skydb/version'

data/lib/skydb/client.rb

@@ -1,5 +1,20 @@
+require 'net/http'
+require 'json'
+
 class SkyDB
   class Client
+    ##########################################################################
+    #
+    # Errors
+    #
+    ##########################################################################
+
+    class ServerError < SkyError
+      attr_accessor :status
+    end
+
+    
+    
     ##########################################################################
     #
     # Constants
@@ -21,8 +36,6 @@ class SkyDB
 
     # Initializes the client.
     def initialize(options={})
-      @multi_message_max_count = 0
-      
       self.host = options[:host] || DEFAULT_HOST
       self.port = options[:port] || DEFAULT_PORT
     end
@@ -40,9 +53,6 @@ class SkyDB
     # The port on the host to connect to.
     attr_accessor :port
 
-    # The name of the table to connect to.
-    attr_accessor :table_name
-
 
     ##########################################################################
     #
@@ -51,256 +61,246 @@ class SkyDB
     ##########################################################################
     
     ####################################
-    # Table Messages
+    # Table API
     ####################################
 
+    # Retrieves a list of tables on the server.
+    def get_tables(options={})
+      data = send(:get, "/tables")
+      tables = data.map {|i| Table.new(:client => self).from_hash(i)}
+      return tables
+    end
+
+    # Retrieves a single table from the server.
+    def get_table(name, options={})
+      raise ArgumentError.new("Table name required") if name.nil?
+      data = send(:get, "/tables/#{name}")
+      table = Table.new(:client => self).from_hash(data)
+      return table
+    end
+
     # Creates a table on the server.
     #
-    # @param [Table] table  the table to add.
+    # @param [Table] table  the table to create.
     def create_table(table, options={})
-      return send_message(SkyDB::Message::CreateTable.new(table, options))
+      raise ArgumentError.new("Table required") if table.nil?
+      table = Table.new(table) if table.is_a?(Hash)
+      table.client = self
+      data = send(:post, "/tables", table.to_hash)
+      return table.from_hash(data)
     end
 
     # Deletes a table on the server.
     #
     # @param [Table] table  the table to delete.
     def delete_table(table, options={})
-      return send_message(SkyDB::Message::DeleteTable.new(table, options))
-    end
-
-    # Retrieves an individual table from the server, if it exists. Otherwise
-    # returns nil.
-    #
-    # @param [Fixnum] name  the table name to retrieve.
-    def get_table(name, options={})
-      return send_message(SkyDB::Message::GetTable.new(name, options))
-    end
-
-    # Retrieves a list of all tables on the server.
-    def get_tables(options={})
-      return send_message(SkyDB::Message::GetTables.new(options))
+      raise ArgumentError.new("Table required") if table.nil?
+      table = Table.new(table) if table.is_a?(Hash)
+      table.client = self
+      send(:delete, "/tables/#{table.name}")
+      return nil
     end
 
 
     ####################################
-    # Action Messages
+    # Property API
     ####################################
 
-    # Adds an action to the server.
+    # Retrieves a list of all properties on a table.
     #
-    # @param [Action] action  the action to add.
-    def add_action(action, options={})
-      return send_message(SkyDB::Message::AddAction.new(action, options))
+    # @return [Array]  the list of properties on the table.
+    def get_properties(table, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      properties = send(:get, "/tables/#{table.name}/properties")
+      properties.map!{|p| Property.new().from_hash(p)}
+      return properties
     end
 
-    # Retrieves an individual action from the server.
+    # Retrieves a single property by name.
     #
-    # @param [Fixnum] action_id  the identifier of the action to retrieve.
-    def get_action(action_id, options={})
-      return send_message(SkyDB::Message::GetAction.new(action_id, options))
-    end
-
-    # Retrieves a list of all actions from the server.
-    def get_actions(options={})
-      return send_message(SkyDB::Message::GetActions.new(options))
+    # @param [Table] table  The table to retrieve from.
+    # @param [String] name  The name of the property to retrieve.
+    #
+    # @return [Array]  the list of properties on the table.
+    def get_property(table, name, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      data = send(:get, "/tables/#{table.name}/properties/#{name}")
+      return Property.new().from_hash(data)
     end
 
-
-    ####################################
-    # Property Messages
-    ####################################
-
-    # Adds a property to the server.
+    # Creates a property on a table.
     #
-    # @param [Property] property  the property to add.
-    def add_property(property, options={})
-      return send_message(SkyDB::Message::AddProperty.new(property, options))
+    # @param [Property] property  the property to create.
+    def create_property(table, property, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Property required") if property.nil?
+      property = Property.new(property) if property.is_a?(Hash)
+      data = send(:post, "/tables/#{table.name}/properties", property.to_hash)
+      return property.from_hash(data)
     end
 
-    # Retrieves an individual property from the server.
+    # Updates a property on a table.
     #
-    # @param [Fixnum] property_id  the identifier of the property to retrieve.
-    def get_property(property_id, options={})
-      return send_message(SkyDB::Message::GetProperty.new(property_id, options))
+    # @param [Property] property  the property to update.
+    def update_property(table, property, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Property required") if property.nil?
+      raise ArgumentError.new("Property name required") if property.name.to_s == ''
+      property = Property.new(property) if property.is_a?(Hash)
+      data = send(:patch, "/tables/#{table.name}/properties/#{property.name}", property.to_hash)
+      return property.from_hash(data)
     end
 
-    # Retrieves a list of all properties from the server.
-    def get_properties(options={})
-      return send_message(SkyDB::Message::GetProperties.new(options))
+    # Deletes a property on a table.
+    #
+    # @param [Property] property  the property to delete.
+    def delete_property(table, property, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Property required") if property.nil?
+      raise ArgumentError.new("Property name required") if property.name.to_s == ''
+      property = Property.new(property) if property.is_a?(Hash)
+      send(:delete, "/tables/#{table.name}/properties/#{property.name}")
+      return nil
     end
 
 
     ####################################
-    # Event Messages
+    # Event API
     ####################################
 
-    # Adds an event to the server.
+    # Retrieves all events for a given object.
     #
-    # @param [Event] event  the event to add.
-    def add_event(event, options={})
-      return send_message(SkyDB::Message::AddEvent.new(event, options))
+    # @return [Array]  the list of events on the table.
+    def get_events(table, object_id, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Object identifier required") if object_id.nil?
+      events = send(:get, "/tables/#{table.name}/objects/#{object_id}/events")
+      events.map!{|e| Event.new().from_hash(e)}
+      return events
     end
 
-
-    ####################################
-    # Path Messages
-    ####################################
-
-    # Finds a count of the action that occurs immediately after a set of
-    # actions.
+    # Retrieves the event that occurred at a given point in time for an object.
     #
-    # @param [Array] prior_action_ids  the prior action ids to match on.
-    def next_actions(prior_action_ids, options={})
-      return send_message(SkyDB::Message::NextActions.new(prior_action_ids, options))
+    # @return [Event]  the event.
+    def get_event(table, object_id, timestamp, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Object identifier required") if object_id.nil?
+      raise ArgumentError.new("Timestamp required") if timestamp.nil?
+      data = send(:get, "/tables/#{table.name}/objects/#{object_id}/events/#{SkyDB.format_timestamp(timestamp)}")
+      return Event.new().from_hash(data)
     end
 
-
-    ####################################
-    # Utility message
-    ####################################
-
-    # Checks if the server is up and running.
+    # Adds an event to an object.
     #
-    # @returns [Boolean]  a flag stating if the server is running.
-    def ping(options={})
-      begin
-        send_message(SkyDB::Message::Ping.new(options))
-        return true
-      rescue
-        return false
-      end
-    end
+    # @param [Table] table  the table the object belongs to.
+    # @param [String] object_id  the object's identifier.
+    # @param [Event] event  the event to add.
+    #
+    # @return [Event]  the event.
+    def add_event(table, object_id, event, options={})
+      options = {:method => :merge}.merge(options)
+      
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Object identifier required") if object_id.nil?
+      raise ArgumentError.new("Event required") if event.nil?
+      event = Event.new(event) if event.is_a?(Hash)
+      raise ArgumentError.new("Event timestamp required") if event.timestamp.nil?
+
+      # The insertion method is communicated to the server through the HTTP method.
+      http_method = case options[:method]
+        when :replace then :put
+        when :merge then :patch
+        else raise ArgumentError.new("Invalid event insertion method: #{options[:method]}")
+        end
 
-    # Looks up lists of actions and properties by name.
-    def lookup(options={})
-      send_message(SkyDB::Message::Lookup.new(options))
-      return nil
+      # Send the event and parse it when it comes back. It could have changed.
+      data = send(http_method, "/tables/#{table.name}/objects/#{object_id}/events/#{SkyDB.format_timestamp(event.timestamp)}", event.to_hash)
+      return event.from_hash(data)
     end
 
-
-    ####################################
-    # Lua Messages
-    ####################################
-
-    # Executes a Lua aggregation job on the server and returns the results.
+    # Deletes an event for an object on a table.
     #
-    # @param [String] source  the Lua source code to execute
-    def aggregate(source, options={})
-      return send_message(SkyDB::Message::Lua::Aggregate.new(source, options))
+    # @param [Table] table  the table the object belongs to.
+    # @param [String] object_id  the object's identifier.
+    # @param [Event] event  the event to delete.
+    def delete_event(table, object_id, event, options={})
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Object identifier required") if object_id.nil?
+      raise ArgumentError.new("Event required") if event.nil?
+      event = Event.new(event) if event.is_a?(Hash)
+      raise ArgumentError.new("Event timestamp required") if event.timestamp.nil?
+      send(:delete, "/tables/#{table.name}/objects/#{object_id}/events/#{SkyDB.format_timestamp(event.timestamp)}")
+      return nil
     end
 
 
     ####################################
-    # Query Interface
+    # Query API
     ####################################
 
-    # Starts a query against the database.
-    def query()
-      return SkyDB::Query.new(:client => self)
-    end
-
-    # Starts a query with a single selection against the database.
+    # Runs a query against a given table.
+    #
+    # @param [Table] table  The table to query.
+    # @param [Hash] q  The query definition to run.
     #
-    # @param [String] fields  a list of properties to select from the database.
-    def select(fields)
-      return query.select(fields)
+    # @return [Results]  the results of the query.
+    def query(table, q)
+      raise ArgumentError.new("Table required") if table.nil?
+      raise ArgumentError.new("Query definition required") if q.nil?
+      q = {:steps => q} if q.is_a?(Array)
+      return send(:post, "/tables/#{table.name}/query", q)
     end
 
 
     ####################################
-    # Multi message
+    # Utility API
     ####################################
 
-    # Executes multiple messages in one call.
-    def multi(options={})
-      raise "Already in a multi-message block" unless @multi_message.nil?
-      
-      # Create multi-message.
-      @multi_message = SkyDB::Message::Multi.new(options)
-      @multi_message_max_count = options[:max_count].to_i
-      
-      # Execute the block normally and send the message.
+    # Pings the server to determine if it is running.
+    #
+    # @return [Boolean]  true if the server is running, otherwise false.
+    def ping(options={})
       begin
-        yield
-        
-        # Send all messages at once.
-        if @multi_message.messages.length > 0
-          send_message(@multi_message)
-        end
-
-      ensure
-        @multi_message = nil
+        send(:get, "/ping")
+      rescue
+        return false
       end
-      
-      return nil
+      return true
     end
-    
+
 
     ####################################
-    # Send
+    # HTTP Utilities
     ####################################
-
-    # Sends a message to the server.
-    #
-    # @param [SkyDB::Message] message  the message to send.
-    # @return [Object]  the object returned by the server.
-    def send_message(message)
-      # Set the table if they're not set.
-      message.table_name = table_name if message.table_name.nil? || message.table_name.empty?
-
-      # Validate message before sending.
-      message.validate!
-      
-      # If this is part of a multi message then simply append the message for
-      # later sending.
-      if !@multi_message.nil? && @multi_message != message
-        @multi_message.messages << message
-        
-        # Send off the MULTI if the message count is above our limit.
-        if @multi_message_max_count > 0 && @multi_message.messages.length >= @multi_message_max_count
-          send_message(@multi_message)
-          @multi_message = SkyDB::Message::Multi.new()
+    
+    # Executes a RESTful JSON over HTTP POST.
+    def send(method, path, data=nil)
+      # Generate a JSON request.
+      request = case method
+        when :get then Net::HTTP::Get.new(path)
+        when :post then Net::HTTP::Post.new(path)
+        when :patch then Net::HTTP::Patch.new(path)
+        when :put then Net::HTTP::Put.new(path)
+        when :delete then Net::HTTP::Delete.new(path)
         end
-        
-        return nil
-      
-      # Otherwise send the message immediately.
-      else
-        begin
-          # Connect to the server.
-          socket = TCPSocket.new(host, port.to_i)
-      
-          # Encode and send message request.
-          message.encode(socket)
-      
-          # Retrieve the respose as a buffer so we can inspect it.
-          #msg, x = *socket.recvmsg
-          #buffer = StringIO.new(msg)
-          #puts "[#{message.message_name}]< #{buffer.string.to_hex}" if SkyDB.debug
+      request.add_field('Content-Type', 'application/json')
+      request.body = JSON.generate(data, :max_nesting => 200) unless data.nil?
+      response = Net::HTTP.new(host, port).start {|http| http.request(request) }
       
-          # Decode msgpack response. There should only be one return object.
-          response = nil
-          unpacker = MessagePack::Unpacker.new(socket)
-          unpacker.each do |obj|
-            response = obj
-            break
-          end
+      # Parse the body as JSON.
+      json = JSON.parse(response.body) rescue nil
+      message = json['message'] rescue nil
       
-          # Close socket.
-          socket.close()
-      
-          # TODO: Exception processing.
-      
-          # Process response back through the message.
-          response = message.process_response(response)
-      
-          # Return response.
-          return response
+      warn("#{method.to_s.upcase} #{path}: #{request.body} -> #{response.body}") if SkyDB.debug
 
-        ensure
-          # Make sure we remove the multi-message if that's what we're sending.
-          @multi_message = nil if @multi_message == message
-        end
+      # Process based on the response code.
+      case response
+      when Net::HTTPSuccess then
+        return json
+      else
+        e = ServerError.new(message)
+        e.status = response.code
+        raise e
       end
     end
   end