syncano 3.1.1.beta → 3.1.1.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b60ab5d1367c53ed95d4be884d3e4db7bde5259
-  data.tar.gz: 393e5d874af1e291d5281a4072b95654024aae2b
+  metadata.gz: ac6af4d016919012111232a83c25611b78f7dfe5
+  data.tar.gz: c05ac4801c237b661c186a6bbfda7d0f835a65e5
 SHA512:
-  metadata.gz: 4a2f19cb61eea646089ec03a2fbd2dc21e84b3425d699e2ca8b29afa8eacbd3e4c868ca8a00bcaa0e91fca80e25a4c29041dc1deb49168a32c060cdbbe8ad0d7
-  data.tar.gz: 49755d9f9a68ac8c6ca5d4778e4d0925ae0f8447b7e976399e3cd69972d37876ac23e450525784013e7f07dece271c7d739cd63ef65b81b8972be7765695f36f
+  metadata.gz: 15fa18f3ad11ac370beeec7d0ebeccc73bae2e63ea0de668ac2055517229bafab40d66fa44b458daf8a05991d00bb968d3bccee226ef24968f67d92e1798b035
+  data.tar.gz: 2119169c94e58495816e98258ed551f937b44788bb673ab96a254da77c6659d563f9e2b3f08752b338875e1b0900992205d258159ed29ac7f9d7fadb579221b2

data/README.md

@@ -1,16 +1,16 @@
 # Syncano
 
-Syncano ruby gem provides communication with Syncano ([www.syncano.com](www.syncano.com)) via HTTPS RESTful interface and TCP sockets.
+Syncano ruby gem provides communication with Syncano ([www.syncano.com](http://www.syncano.com)) via HTTPS RESTful interface and TCP sockets.
 
 The full source code can be found on [Github](https://github.com/Syncano/syncano-ruby) - feel free to browse or contribute.
 
-Click here to learn more about [Syncano](www.syncano.com) or [create an account](https://login.syncano.com/sign_up)!
+Click here to learn more about [Syncano](http://www.syncano.com) or [create an account](https://login.syncano.com/sign_up)!
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'syncano'
+    gem 'syncano', '~> 3.1.1.beta2'
 
 And then execute:
 
@@ -18,7 +18,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install syncano
+    $ gem install syncano -v 3.1.1.beta2 --pre
     
 At the end generate initializer with api key and api instance name:
 
@@ -56,6 +56,18 @@ client.disconnect
 ```
 * managing callbacks for handling notifications (it is described later in this document)
 
+#### User api key
+
+If you want to use an user api key, you have to pass auth key or username and password to the client's constructor.
+
+```ruby
+client = Syncano.client(api_key: 'api key', instance_name: 'instance name', auth_key: 'auth key')
+```
+
+```ruby
+client = Syncano.client(api_key: 'api key', instance_name: 'instance name', username: 'username', password: 'password')
+```
+
 ### Resources
 
 Syncano gem utilizes an ActiveRecord pattern for managing resources. You can use it in similar way with both type of clients.
@@ -85,7 +97,9 @@ Below is a list of all implemented resources with information about what methods
 
 #### Project
 
-Implements all standard methods.
+Implements all standard methods and following custom:
+
+* project.authorize(api_key_id, permission)
 
 ##### Examples
 
@@ -108,6 +122,12 @@ project[:description] = 'Lorem ipsum'
 project.save
 ```
 
+* Authorizing user api key with read permission
+
+```ruby
+project.authorize(api_key_id, 'read_data')
+```
+
 #### Collection
 
 Implements all standard methods and following custom:
@@ -117,6 +137,7 @@ Implements all standard methods and following custom:
 * collection.deactivate
 * collection.add_tag(tag, weight, remove_others)
 * collection.delete_tag(tag)
+* collection.authorize(api_key_id, permission)
 
 ##### Examples
 
@@ -150,6 +171,7 @@ collection2.add_tags('tag3', 1, true)
 Implements all standard methods and following custom:
 
 * folders.find_by_name(folder_name)
+* folder.authorize(api_key_id, permission)
 
 Find method uses folder name as a key.
 

data/lib/syncano.rb

@@ -7,7 +7,9 @@ class Syncano
   # @return [Syncano::Clients::Rest] Syncano client.
   def self.client(options = {})
     auth_data = self.auth_data(options)
-    Syncano::Clients::Rest.new(auth_data[:instance_name], auth_data[:api_key])
+    client = Syncano::Clients::Rest.new(auth_data[:instance_name], auth_data[:api_key], auth_data[:auth_key])
+    client.login(options[:username], options[:password]) if client.auth_key.nil? && options[:username].present?
+    client
   end
 
   # Used for initializing Syncano Sync Client
@@ -15,7 +17,8 @@ class Syncano
   # @return [Syncano::Clients::Rest] Syncano client.
   def self.sync_client(options = {})
     auth_data = self.auth_data(options)
-    client = Syncano::Clients::Sync.instance(auth_data[:instance_name], auth_data[:api_key])
+    client = Syncano::Clients::Sync.instance(auth_data[:instance_name], auth_data[:api_key], auth_data[:auth_key])
+    client.login(options[:username], options[:password]) if client.auth_key.nil? && options[:username].present?
     client.connect
     client
   end
@@ -32,7 +35,7 @@ class Syncano
     api_key = options[:api_key] || ::SYNCANO_API_KEY
     raise 'Syncano api key cannot be blank!' if api_key.nil?
 
-    { instance_name: instance_name, api_key: api_key }
+    { instance_name: instance_name, api_key: api_key, auth_key: options[:auth_key] }
   end
 end
 

data/lib/syncano/clients/base.rb

@@ -3,16 +3,24 @@ class Syncano
   module Clients
     # Base class for representing clients
     class Base
-      attr_reader :instance_name, :api_key
+      attr_reader :instance_name, :api_key, :auth_key
 
       # Constructor for Syncano::Clients::Base object
       # @param [String] instance_name
       # @param [String] api_key
-      def initialize(instance_name, api_key)
+      def initialize(instance_name, api_key, auth_key)
         super()
 
         self.instance_name = instance_name
         self.api_key = api_key
+        self.auth_key = auth_key if auth_key.present?
+      end
+
+      # Deletes saved auth_key
+      # @return [TrueClass, FalseClass]
+      def logout
+        self.auth_key = nil
+        self.auth_key.nil?
       end
 
       # Returns query builder for Syncano::Resources::Admin objects
@@ -66,8 +74,8 @@ class Syncano
       # @param [Integer, String] project_id
       # @param [Integer, String] collection_id
       # @return [Syncano::QueryBuilder]
-      def users(project_id, collection_id)
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::User, project_id: project_id, collection_id: collection_id)
+      def users
+        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::User)
       end
 
       # Performs request to Syncano api
@@ -91,7 +99,7 @@ class Syncano
 
       private
 
-      attr_writer :instance_name, :api_key
+      attr_writer :instance_name, :api_key, :auth_key
 
       # Parses Syncano api response and returns Syncano::Response object
       # @param [String] response_key
@@ -101,8 +109,8 @@ class Syncano
         status = raw_response.nil? || raw_response['result'] != 'NOK'
         if raw_response.nil?
           data = nil
-        elsif raw_response[response_key].present?
-          data = raw_response[response_key]
+        elsif raw_response[response_key.to_s].present?
+          data = raw_response[response_key.to_s]
         else
           data = raw_response['count']
         end

data/lib/syncano/clients/rest.rb

@@ -7,11 +7,19 @@ class Syncano
       # Constructor for Syncano::Clients::Rest object
       # @param [String] instance_name
       # @param [String] api_key
-      def initialize(instance_name, api_key)
-        super(instance_name, api_key)
+      def initialize(instance_name, api_key, auth_key = nil)
+        super(instance_name, api_key, auth_key)
         self.client = ::Jimson::Client.new(json_rpc_url)
       end
 
+      # Gets auth_key based on username and password
+      # @return [TrueClass, FalseClass]
+      def login(username, password)
+        logout
+        self.auth_key = users.login(username, password)
+        !self.auth_key.nil?
+      end
+
       # Performs request to Syncano api
       # @param [String] resource_name
       # @param [String] method_name
@@ -19,6 +27,8 @@ class Syncano
       # @param [String] response_key for cases when response from api is incompatible with the convention
       # @return [Syncano::Response]
       def make_request(resource_name, method_name, params = {}, response_key = nil)
+        params.merge!(auth_key: auth_key) if auth_key.present?
+
         response_key ||= resource_name
         response = client.send("#{resource_name}.#{method_name}", request_params.merge(params))
         response = self.class.parse_response(response_key, response)

data/lib/syncano/clients/sync.rb

@@ -9,20 +9,21 @@ class Syncano
       # Constructor for Syncano::Clients::Sync object
       # @param [String] instance_name
       # @param [String] api_key
-      def initialize(instance_name, api_key)
-        super(instance_name, api_key)
+      def initialize(instance_name, api_key, auth_key = nil)
+        super(instance_name, api_key, auth_key)
         self.connection = nil
+        self.auth_key = auth_key if auth_key.present?
       end
 
       # Getter for Singleton instance
       # @param [String] instance_name
       # @param [String] api_key
       # @return [Syncano::Clients::Base]
-      def self.instance(instance_name = nil, api_key = nil)
+      def self.instance(instance_name = nil, api_key = nil, auth_key = nil)
         unless @singleton__instance__
           @singleton__mutex__.synchronize do
             return @singleton__instance__ if @singleton__instance__
-            @singleton__instance__ = new(instance_name, api_key)
+            @singleton__instance__ = new(instance_name, api_key, auth_key)
           end
         end
         @singleton__instance__
@@ -53,6 +54,15 @@ class Syncano
           end
 
           raise ::Syncano::ConnectionError.new('Connection timeout') unless timeout > 0
+
+          timeout = 300
+
+          while (response = connection.get_response('auth')).blank? && timeout > 0
+            timeout -= 1
+            sleep 1.0/10.0
+          end
+
+          raise ::Syncano::ConnectionError.new(response.error) if response.status == 'NOK'
         end
       end
 
@@ -68,6 +78,15 @@ class Syncano
         connect
       end
 
+      # Gets auth_key based on username and password
+      # @return [TrueClass, FalseClass]
+      def login(username, password)
+        logout
+        rest_client = ::Syncano.client(api_key: api_key)
+        self.auth_key = rest_client.users.login(username, password)
+        !self.auth_key.nil?
+      end
+
       # Returns query builder for Syncano::Resources::Subscription objects
       # @return [Syncano::QueryBuilder]
       def subscriptions
@@ -124,8 +143,10 @@ class Syncano
           end
         end
 
+        raise(::Syncano::ApiError.new('Request timeout error!')) if timer == 0
+
         response = self.class.parse_response(response_key, response_packet.to_response)
-        response.errors.present? ? raise(Syncano::ApiError.new(response.errors)) : response
+        response.errors.present? ? raise(::Syncano::ApiError.new(response.errors)) : response
       end
     end
   end

data/lib/syncano/errors.rb

@@ -10,4 +10,8 @@ class Syncano
   # Class representing errors during connections
   class ConnectionError < BaseError
   end
+
+  # Class representing timeout errors
+  class TimeoutError < BaseError
+  end
 end

data/lib/syncano/packets/auth.rb

@@ -2,6 +2,26 @@ class Syncano
   module Packets
     # Class representing auth packets used in communication with the Sync Server
     class Auth < Syncano::Packets::Base
+      attr_reader :message_id, :status, :error
+
+      # Constructor for Syncano::Packets::Auth object
+      # @param [Hash] attributes
+      def initialize(attributes)
+        super(attributes)
+        self.message_id = 'auth'
+        self.status = attributes[:result]
+        self.error = attributes[:error]
+      end
+
+      # Returns true if is an auth packet
+      # @return [TrueClass, FalseClass]
+      def auth?
+        true
+      end
+
+      private
+
+      attr_writer :message_id, :status, :error
     end
   end
 end

data/lib/syncano/packets/base.rb

@@ -56,6 +56,12 @@ class Syncano
         false
       end
 
+      # Returns true if is an auth packet
+      # @return [TrueClass, FalseClass]
+      def auth?
+        false
+      end
+
       private
 
       attr_writer :object, :timestamp

data/lib/syncano/query_builder.rb

@@ -51,7 +51,7 @@ class Syncano
     # @param [Integer, String] key
     # @param [Hash] conditions
     # @return [Syncano::Resources::Base]
-    def find(key, conditions = {})
+    def find(key = nil, conditions = {})
       resource_class.find(client, key, scope_parameters, conditions)
     end
 
@@ -137,6 +137,14 @@ class Syncano
       resource_class.batch_move(batch_client, scope_parameters, ids, conditions, new_folder, new_state)
     end
 
+    # Proxy for calling "login" method on the resource object
+    # @param [String] username
+    # @param [String] password
+    # @return [Array] collection of Syncano::Resource objects
+    def login(username = nil, password = nil)
+      resource_class.login(client, username, password)
+    end
+
     private
 
     attr_accessor :client, :resource_class, :scope_parameters

data/lib/syncano/resources/api_key.rb

@@ -8,14 +8,48 @@ class Syncano
       def initialize(client, attributes = {})
         super(client, attributes)
         if @attributes[:role].is_a?(Hash)
-          @attributes[:role] = ::Syncano::Resources::Role.new(@attributes[:role])
+          @attributes[:role] = ::Syncano::Resources::Role.new(client, @attributes[:role])
         end
 
         if @saved_attributes[:role].is_a?(Hash)
-          @saved_attributes[:role] = ::Syncano::Resources::Role.new(@saved_attributes[:role])
+          @saved_attributes[:role] = ::Syncano::Resources::Role.new(client, @saved_attributes[:role])
         end
       end
 
+      # Wrapper for api "authorize" method
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def authorize(permission)
+        perform_authorize(nil, permission: permission)
+        self
+      end
+
+      # Wrapper for api "authorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_authorize(batch_client, permission)
+        perform_authorize(batch_client, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def deauthorize(permission)
+        perform_deauthorize(nil, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_deauthorize(batch_client, permission)
+        perform_deauthorize(batch_client, permission: permission)
+        self
+      end
+
       private
 
       # Prepares attributes to synchronizing with Syncano
@@ -34,6 +68,18 @@ class Syncano
         :api_client_id
       end
 
+      # Executes proper find request
+      # @param [Syncano::Clients::Base] client
+      # @param [Symbol, String] key_name
+      # @param [Integer, String] key
+      # @param [Hash] scope_parameters
+      # @param [Hash] conditions
+      # @return [Syncano::Response]
+      def self.perform_find(client, key_name, key, scope_parameters, conditions)
+        key_parameters = key.present? ? { key_name.to_sym => key } : {}
+        make_request(client, nil, :find, conditions.merge(scope_parameters.merge(key_parameters)))
+      end
+
       # Executes proper update request
       # @param [Jimson::BatchClient] batch_client
       # @param [Hash] attributes
@@ -41,6 +87,22 @@ class Syncano
       def perform_update(batch_client, attributes)
         self.class.make_request(client, batch_client, :update_description, self.class.attributes_to_sync(attributes).merge(self.class.primary_key_name.to_sym => primary_key))
       end
+
+      # Executes proper authorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_authorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :authorize, parameters.merge(self.class.primary_key_name.to_sym => primary_key))
+      end
+
+      # Executes proper deauthorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_deauthorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :deauthorize, parameters.merge(self.class.primary_key_name.to_sym => primary_key))
+      end
     end
   end
 end

data/lib/syncano/resources/collection.rb

@@ -118,6 +118,44 @@ class Syncano
         reload!
       end
 
+      # Wrapper for api "authorize" method
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def authorize(api_client_id, permission)
+        perform_authorize(nil, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "authorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_authorize(batch_client, api_client_id, permission)
+        perform_authorize(batch_client, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def deauthorize(api_client_id, permission)
+        perform_deauthorize(nil, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_deauthorize(batch_client, api_client_id, permission)
+        perform_deauthorize(batch_client, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
       private
 
       self.scope_parameters = [:project_id]
@@ -181,6 +219,22 @@ class Syncano
         check_if_sync_client!
         client.make_request(:subscription, :unsubscribe_collection, scope_parameters.merge(collection_id: id))
       end
+
+      # Executes proper authorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_authorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :authorize, scope_parameters.merge(parameters.merge(self.class.primary_key_name.to_sym => primary_key)))
+      end
+
+      # Executes proper deauthorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_deauthorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :deauthorize, scope_parameters.merge(parameters.merge(self.class.primary_key_name.to_sym => primary_key)))
+      end
     end
   end
 end

data/lib/syncano/resources/folder.rb

@@ -18,6 +18,44 @@ class Syncano
         find(client, name, scope_parameters, conditions)
       end
 
+      # Wrapper for api "authorize" method
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def authorize(api_client_id, permission)
+        perform_authorize(nil, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "authorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_authorize(batch_client, api_client_id, permission)
+        perform_authorize(batch_client, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def deauthorize(api_client_id, permission)
+        perform_deauthorize(nil, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_deauthorize(batch_client, api_client_id, permission)
+        perform_deauthorize(batch_client, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
       private
 
       self.primary_key = :name
@@ -29,6 +67,22 @@ class Syncano
       def perform_destroy(batch_client)
         self.class.make_request(client, batch_client, :destroy, scope_parameters.merge(name: primary_key))
       end
+
+      # Executes proper authorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_authorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :authorize, scope_parameters.merge(parameters.merge(self.class.primary_key_name.to_sym => primary_key)))
+      end
+
+      # Executes proper deauthorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_deauthorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :deauthorize, scope_parameters.merge(parameters.merge(self.class.primary_key_name.to_sym => primary_key)))
+      end
     end
   end
 end

data/lib/syncano/resources/project.rb

@@ -22,6 +22,44 @@ class Syncano
         reload!
       end
 
+      # Wrapper for api "authorize" method
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def authorize(api_client_id, permission)
+        perform_authorize(nil, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "authorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_authorize(batch_client, api_client_id, permission)
+        perform_authorize(batch_client, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def deauthorize(api_client_id, permission)
+        perform_deauthorize(nil, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
+      # Wrapper for api "deauthorize" method
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Integer] api_client_id
+      # @param [String] permission
+      # @return [Syncano::Resources::Base]
+      def batch_deauthorize(batch_client, api_client_id, permission)
+        perform_deauthorize(batch_client, api_client_id: api_client_id, permission: permission)
+        self
+      end
+
       private
 
       # Executes proper subscribe request
@@ -37,6 +75,22 @@ class Syncano
         check_if_sync_client!
         client.make_request(:subscription, :unsubscribe_project, { project_id: id })
       end
+
+      # Executes proper authorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_authorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :authorize, parameters.merge(self.class.primary_key_name.to_sym => primary_key))
+      end
+
+      # Executes proper deauthorize request
+      # @param [Jimson::BatchClient] batch_client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def perform_deauthorize(batch_client, parameters)
+        self.class.make_request(client, batch_client, :deauthorize, parameters.merge(self.class.primary_key_name.to_sym => primary_key))
+      end
     end
   end
 end

data/lib/syncano/resources/user.rb

@@ -12,6 +12,16 @@ class Syncano
         response.data if response.status
       end
 
+      # Wrapper for api "login" method
+      # @param [Syncano::Clients::Base] client
+      # @param [String] username
+      # @param [String] password
+      # @return [Integer]
+      def self.login(client, username, password)
+        response = perform_login(client, user_name: username, password: password)
+        response.data
+      end
+
       private
 
       self.scope_parameters = [:project_id, :collection_id]
@@ -42,6 +52,14 @@ class Syncano
       def self.perform_count(client, scope_parameters, conditions)
         make_request(client, nil, :count, conditions.merge(scope_parameters))
       end
+
+      # Executes proper login request
+      # @param [Syncano::Clients::Base] client
+      # @param [Hash] parameters
+      # @return [Syncano::Response]
+      def self.perform_login(client, parameters = {})
+        make_request(client, nil, :login, parameters, :auth_key)
+      end
     end
   end
 end

data/lib/syncano/sync_connection.rb

@@ -21,13 +21,15 @@ class Syncano
       start_tls
     end
 
-    # Eventmachine callback invoked completing ssl handshake
+    # Eventmachine callback invoked after completing ssl handshake
     def ssl_handshake_completed
       auth_data = {
         api_key: client.api_key,
         instance: client.instance_name
       }
 
+      auth_data[:auth_key] = client.auth_key if client.auth_key.present?
+
       client.connection = self
 
       send_data "#{auth_data.to_json}\n"
@@ -47,6 +49,8 @@ class Syncano
         end
       elsif packet.call_response?
         queue_response(packet)
+      elsif packet.auth?
+        queue_response(packet)
       end
     end
 
@@ -77,7 +81,7 @@ class Syncano
     # @param [Integer, String] message_id
     # @return [Syncano::Packets::CallResponse]
     def get_response(message_id)
-      responses.delete(message_id)
+      responses.delete(message_id.to_s)
     end
 
     private
@@ -88,9 +92,9 @@ class Syncano
     # @param [Syncano::Packets::CallResponse] packet
     def queue_response(packet)
       prune_responses_queue
-      message_id = packet.message_id.to_i
+      message_id = packet.message_id.to_s
       responses[message_id] = packet
-      responses_queue << message_id
+      responses_queue << message_id.to_s
     end
 
     # Removes old call response packets from the responses queue
@@ -98,7 +102,7 @@ class Syncano
       while !responses_queue.empty?
         message_id = responses_queue.first
 
-        if responses_queue[message_id].nil? || Time.now - responses[message_id].timestamp.to_time > 2.minutes
+        if responses[message_id].nil? || Time.now - responses[message_id].timestamp.to_time > 2.minutes
           responses_queue.shift
           responses.delete(message_id)
         else

data/lib/syncano/version.rb

@@ -1,4 +1,4 @@
 class Syncano
   # Syncano version number
-  VERSION = '3.1.1.beta'
+  VERSION = '3.1.1.beta2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syncano
 version: !ruby/object:Gem::Version
-  version: 3.1.1.beta
+  version: 3.1.1.beta2
 platform: ruby
 authors:
 - Piotr Zadrożny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-27 00:00:00.000000000 Z
+date: 2014-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jimson-client