syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/batch_queue.rb

@@ -1,58 +0,0 @@
-class Syncano
-  # Class representing queues used in batch requests
-  class BatchQueue
-    # Limit for amount of batch operations send in one request
-    REQUEST_LIMIT = 10
-    attr_reader :responses
-
-    # Constructor for Syncano::BatchQueue
-    # @param [Syncano::Clients::Base] client
-    def initialize(client)
-      super()
-      self.client = client
-      self.queue = []
-      self.responses = []
-    end
-
-    # Adds element to the queue and prune it if is full
-    # @param [Syncano::BatchQueueElement] element
-    def add(element)
-      self.queue << element
-      prune! while full?
-    end
-
-    # Alias for "add" method
-    # @param [Syncano::BatchQueueElement] element
-    def <<(element)
-      add(element)
-    end
-
-    # Counts elements in the queue
-    # @return [Integer]
-    def count
-      queue.count
-    end
-
-    # Checks if queue is full
-    # @return [TrueClass, FalseClass]
-    def full?
-      count >= REQUEST_LIMIT
-    end
-
-    # Prunes queue and makes batch request to the api
-    # @return [Array] collection of Syncano::Response objects
-    def prune!
-      part = self.queue.slice!(0, 10)
-      ::Jimson::Client.batch(client) do |batch_client|
-        part.each do |element|
-          element.perform!(batch_client)
-        end
-      end.collect { |response| self.responses << response }
-    end
-
-    protected
-
-    attr_accessor :client, :queue
-    attr_writer :responses
-  end
-end

data/lib/syncano/batch_queue_element.rb

@@ -1,33 +0,0 @@
-class Syncano
-  # Class representing objects batch requests queued for processing
-  class BatchQueueElement
-    # Constructor for Syncano::BatchQueueElement
-    # @param [Syncano::QueryBuilder, Syncano::Resources::Base] resource
-    def initialize(resource)
-      super()
-      self.resource = resource.dup
-    end
-
-    # Overwritten method_missing used for preparing execution of proper batch method on the resource object
-    # @param [Symbol] sym
-    # @param [Array] args
-    # @param [Proc] block
-    # @return [Syncano::BatchQueueElement]
-    def method_missing(sym, *args, &block)
-      self.method_name = 'batch_' + sym.to_s
-      self.args = args
-      self.block = block
-      self
-    end
-
-    # Executes batch method on the resource object
-    def perform!(batch_client)
-      args.unshift(batch_client)
-      resource.send(method_name, *args, &block)
-    end
-
-    private
-
-    attr_accessor :resource, :method_name, :args, :block
-  end
-end

data/lib/syncano/clients/base.rb

@@ -1,123 +0,0 @@
-class Syncano
-  # Module used as a scope for classes representing clients
-  module Clients
-    # Base class for representing clients
-    class Base
-      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, 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
-      # @return [Syncano::QueryBuilder]
-      def admins
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Admin)
-      end
-
-      # Returns query builder for Syncano::Resources::ApiKey objects
-      # @return [Syncano::QueryBuilder]
-      def api_keys
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::ApiKey)
-      end
-
-      # Returns query builder for Syncano::Resources::Role objects
-      # @return [Syncano::QueryBuilder]
-      def roles
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Role)
-      end
-
-      # Returns query builder for Syncano::Resources::Project objects
-      # @return [Syncano::QueryBuilder]
-      def projects
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Project)
-      end
-
-      # Returns query builder for Syncano::Resources::Project objects
-      # @param [Integer, String] project_id
-      # @return [Syncano::QueryBuilder]
-      def collections(project_id)
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Collection, project_id: project_id)
-      end
-
-      # Returns query builder for Syncano::Resources::Folder objects
-      # @param [Integer, String] project_id
-      # @param [Integer, String] collection_id
-      # @return [Syncano::QueryBuilder]
-      def folders(project_id, collection_id)
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Collection, project_id: project_id, collection_id: collection_id)
-      end
-
-      # Returns query builder for Syncano::Resources::DataObject objects
-      # @param [Integer, String] project_id
-      # @param [Integer, String] collection_id
-      # @return [Syncano::QueryBuilder]
-      def data_objects(project_id, collection_id)
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::DataObject, project_id: project_id, collection_id: collection_id)
-      end
-
-      # Returns query builder for Syncano::Resources::User objects
-      # @param [Integer, String] project_id
-      # @param [Integer, String] collection_id
-      # @return [Syncano::QueryBuilder]
-      def users
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::User)
-      end
-
-      # Performs request to Syncano api
-      # This should be overwritten in inherited classes
-      # @param [String] resource_name
-      # @param [String] method_name
-      # @param [Hash] params additional params sent in the request
-      # @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)
-      end
-
-      # Performs batch request to Syncano api
-      # This should be overwritten in inherited classes
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String] resource_name
-      # @param [String] method_name
-      # @param [Hash] params additional params sent in the request
-      def make_batch_request(batch_client, resource_name, method_name, params = {})
-      end
-
-      private
-
-      attr_writer :instance_name, :api_key, :auth_key
-
-      # Parses Syncano api response and returns Syncano::Response object
-      # @param [String] response_key
-      # @param [Hash] raw_response
-      # @return [Syncano::Response]
-      def self.parse_response(response_key, raw_response)
-        status = raw_response.nil? || raw_response['result'] != 'NOK'
-        if raw_response.nil?
-          data = nil
-        elsif raw_response[response_key.to_s].present?
-          data = raw_response[response_key.to_s]
-        else
-          data = raw_response['count']
-        end
-        errors = status ? [] : raw_response['error']
-
-        ::Syncano::Response.new(status, data, errors)
-      end
-    end
-  end
-end

data/lib/syncano/clients/rest.rb

@@ -1,79 +0,0 @@
-class Syncano
-  module Clients
-    # Client used for communication with the JSON-RPC endpoint
-    class Rest < Syncano::Clients::Base
-      attr_reader :client
-
-      # Constructor for Syncano::Clients::Rest object
-      # @param [String] instance_name
-      # @param [String] 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
-      # @param [Hash] params additional params sent in the request
-      # @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)
-
-        response.errors.present? ? raise(Syncano::ApiError.new(response.errors)) : response
-      end
-
-      # Performs batch request to Syncano api
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String] resource_name
-      # @param [String] method_name
-      # @param [Hash] params additional params sent in the request
-      def make_batch_request(batch_client, resource_name, method_name, params = {})
-        batch_client.send("#{resource_name}.#{method_name}", request_params.merge(params))
-      end
-
-      # Gets block in which Syncano::BatchQueue object is provided and batch requests can be executed
-      # @param [Block]
-      # @return [Array] collection of parsed responses
-      def batch
-        queue = ::Syncano::BatchQueue.new(client)
-        yield(queue)
-        queue.prune!
-
-        queue.responses.collect do |response|
-          resource_name = response.first.method.split('.').first
-          self.class.parse_response(resource_name, response.last.result)
-        end
-      end
-
-      private
-
-      attr_writer :client
-
-      # Generates url to json rpc api
-      # @return [String]
-      def json_rpc_url
-        "https://#{instance_name}.syncano.com/api/jsonrpc"
-      end
-
-      # Prepares hash with default request params
-      # @return [Hash]
-      def request_params
-        { api_key: api_key }
-      end
-    end
-  end
-end

data/lib/syncano/clients/sync.rb

@@ -1,164 +0,0 @@
-class Syncano
-  module Clients
-    # Client used for communication with the Sync Server
-    class Sync < Syncano::Clients::Base
-      include ::Singleton
-
-      attr_accessor :connection
-
-      # Constructor for Syncano::Clients::Sync object
-      # @param [String] instance_name
-      # @param [String] 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, auth_key = nil)
-        unless @singleton__instance__
-          @singleton__mutex__.synchronize do
-            return @singleton__instance__ if @singleton__instance__
-            @singleton__instance__ = new(instance_name, api_key, auth_key)
-          end
-        end
-        @singleton__instance__
-      end
-
-      # Checks if client is connected
-      # @return [TrueClass, FalseClass]
-      def connected?
-        !connection.blank?
-      end
-
-      # Connects with the Sync api
-      def connect
-        unless connected?
-          hostname = 'api.syncano.com'
-          port = 8200
-
-          sleep(3)
-
-          Thread.new do
-            begin
-              EM.run do
-                EM.connect(hostname, port, Syncano::SyncConnection)
-              end
-            rescue Exception => e
-              p e.message
-              p e.backtrace
-            end
-          end
-
-          timeout = 30
-
-          while connection.blank? && timeout > 0
-            timeout -= 1
-            sleep 1
-          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
-
-      # Disconnects with the Sync api
-      def disconnect
-        EM.stop if EM::reactor_running?
-        self.connection = nil
-      end
-
-      # Reconnects with the Sync api
-      def reconnect
-        disconnect
-        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
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Subscription)
-      end
-
-      # Returns query builder for Syncano::Resources::Notifications::Base objects
-      # @return [Syncano::QueryBuilder]
-      def notifications
-        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::Notifications::Base)
-      end
-
-      # Appends callback for processing notifications to the end of callbacks queue
-      # @return [Syncano::QueryBuilder]
-      def append_callback(callback_name, &callback)
-        connection.append_callback(callback_name, callback)
-      end
-
-      # Prepends callback for processing notifications to the beginning of callbacks queue
-      # @return [Syncano::QueryBuilder]
-      def prepend_callback(callback_name, &callback)
-        connection.prepend_callback(callback_name, callback)
-      end
-
-      # Removes callback from the callbacks queue
-      # @return [Syncano::QueryBuilder]
-      def remove_callback(callback_name)
-        connection.remove_callback(callback_name)
-      end
-
-      # Performs request to Syncano api
-      # This should be overwritten in inherited classes
-      # @param [String] resource_name
-      # @param [String] method_name
-      # @param [Hash] params additional params sent in the request
-      # @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)
-        raise(::Syncano::ConnectionError.new('Not connected to the Sync Server!')) unless connected?
-
-        response_key ||= resource_name
-
-        packet = ::Syncano::Packets::Call.new(resource_name: resource_name, method_name: method_name, data: params)
-
-        connection.send_data("#{packet.to_json}\n")
-
-        response_packet = nil
-        timer = 600
-
-        while timer > 0
-          response_packet = connection.get_response(packet.message_id)
-          if response_packet.nil?
-            timer -= 1
-            sleep 1.0 / 10.0
-          else
-            break
-          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
-      end
-    end
-  end
-end