syncano 3.1.1.beta

data/lib/syncano/batch_queue.rb

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,115 @@
+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
+
+      # Constructor for Syncano::Clients::Base object
+      # @param [String] instance_name
+      # @param [String] api_key
+      def initialize(instance_name, api_key)
+        super()
+
+        self.instance_name = instance_name
+        self.api_key = api_key
+      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(project_id, collection_id)
+        ::Syncano::QueryBuilder.new(self, ::Syncano::Resources::User, project_id: project_id, collection_id: collection_id)
+      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
+
+      # 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].present?
+          data = raw_response[response_key]
+        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

@@ -0,0 +1,69 @@
+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)
+        super(instance_name, api_key)
+        self.client = ::Jimson::Client.new(json_rpc_url)
+      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)
+        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

@@ -0,0 +1,132 @@
+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)
+        super(instance_name, api_key)
+        self.connection = nil
+      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)
+        unless @singleton__instance__
+          @singleton__mutex__.synchronize do
+            return @singleton__instance__ if @singleton__instance__
+            @singleton__instance__ = new(instance_name, api_key)
+          end
+        end
+        @singleton__instance__
+      end
+
+      # Connects with the Sync api
+      def connect
+        if connection.blank?
+          hostname = 'api.syncano.com'
+          port = 8200
+
+          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
+        end
+      end
+
+      # Disconnects with the Sync api
+      def disconnect
+        EM.stop
+        self.connection = nil
+      end
+
+      # Reconnects with the Sync api
+      def reconnect
+        disconnect
+        connect
+      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)
+        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
+
+        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

data/lib/syncano/errors.rb

@@ -0,0 +1,13 @@
+class Syncano
+  # General errors
+  class BaseError < RuntimeError
+  end
+
+  # Class represeting errors returned by the Syncano API
+  class ApiError < BaseError
+  end
+
+  # Class representing errors during connections
+  class ConnectionError < BaseError
+  end
+end

data/lib/syncano/jimson_client.rb

@@ -0,0 +1,34 @@
+# Overwritten module from Jimson gem
+module Jimson
+  # Overwritten helper from Jimson gem
+  class ClientHelper
+    # Overwritten send_batch method, so it now returns collection of responses
+    # @return [Array] collection of responses
+    def send_batch
+      batch = @batch.map(&:first) # get the requests
+      response = send_batch_request(batch)
+
+      begin
+        responses = JSON.parse(response)
+      rescue
+        raise Jimson::ClientError::InvalidJSON.new(json)
+      end
+
+      process_batch_response(responses)
+      responses = @batch
+
+      @batch = []
+
+      responses
+    end
+  end
+
+  # Overwritten Request class from Jimson gem
+  class Request
+    # Overwritten as_json method which solves bug with serialization batch requests
+    # @return [Hash]
+    def as_json(options = {})
+      to_h
+    end
+  end
+end