dodgeball-trust-sdk-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: abfd89964ce453124544cf58b89603d36c7ae5286aa52998a53e55d2755d67a5
+  data.tar.gz: 9e04f8b5b691b617d1e1e65df1e613e780023fc75ffe62a0d9b20a28a0450ad3
+SHA512:
+  metadata.gz: 5eed501cfcf9f9d47eaa5f4d1469b2e14ff876212abd012941c2a22634c34986f25a1de91963dfcba8b923ede71752d9923bf6a6c0bfe668e3b597207832e55f
+  data.tar.gz: ded1407e1a0bdb6c530d1650fb8f394ec6f44219b90eaa4a43613d6a05eac2ed01e1610c0e8e23a1a3fca746e88ea8a9215ee06bf67485deb0cb131733320027

data/lib/dodgeball/client/backoff_policy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'dodgeball/client/defaults'
+
+module Dodgeball
+  class Client
+    class BackoffPolicy
+      include Dodgeball::Client::Defaults::BackoffPolicy
+
+      # @param [Hash] opts
+      # @option opts [Numeric] :min_timeout_ms The minimum backoff timeout
+      # @option opts [Numeric] :max_timeout_ms The maximum backoff timeout
+      # @option opts [Numeric] :multiplier The value to multiply the current
+      #   interval with for each retry attempt
+      # @option opts [Numeric] :randomization_factor The randomization factor
+      #   to use to create a range around the retry interval
+      def initialize(opts = {})
+        @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
+        @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
+        @multiplier = opts[:multiplier] || MULTIPLIER
+        @randomization_factor = opts[:randomization_factor] || RANDOMIZATION_FACTOR
+
+        @attempts = 0
+      end
+
+      # @return [Numeric] the next backoff interval, in milliseconds.
+      def next_interval
+        interval = @min_timeout_ms * (@multiplier**@attempts)
+        interval = add_jitter(interval, @randomization_factor)
+
+        @attempts += 1
+
+        [interval, @max_timeout_ms].min
+      end
+
+      private
+
+      def add_jitter(base, randomization_factor)
+        random_number = rand
+        max_deviation = base * randomization_factor
+        deviation = random_number * max_deviation
+
+        if random_number < 0.5
+          base - deviation
+        else
+          base + deviation
+        end
+      end
+    end
+  end
+end

data/lib/dodgeball/client/defaults.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dodgeball
+  class Client
+    module Defaults
+      module Request
+        # HOST/PORT Used for testing
+        HOST = 'localhost'.freeze
+        PORT = 3000.freeze
+        PATH_ROOT = '/v1/'.freeze
+        DODGEBALL_API_URL = 'http://localhost:3000'.freeze
+        
+        DEFAULT_READ_TIMEOUT = 8.freeze
+        DEFAULT_OPEN_TIMEOUT = 4.freeze
+        SSL = true.freeze
+        HEADERS = { 'Accept' => 'application/json',
+                    'Content-Type' => 'application/json',
+                    'User-Agent' => "dodgeball-ruby/#{Client::VERSION}" }.freeze
+        RETRIES = 10.freeze
+
+        SECRET_KEY_HEADER = 'Dodgeball-Secret-Key'.freeze
+        SOURCE_ID_HEADER = 'Dodgeball-Source-Id'.freeze
+        VERIFICATION_ID_HEADER = 'Dodgeball-Verification-Id'.freeze
+      end
+
+      module BackoffPolicy
+        MIN_TIMEOUT_MS = 100.freeze
+        MAX_TIMEOUT_MS = 10000.freeze
+        MULTIPLIER = 1.5.freeze
+        RANDOMIZATION_FACTOR = 0.5.freeze
+      end
+    end
+  end
+end

data/lib/dodgeball/client/logging.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Dodgeball
+  class Client
+    # Wraps an existing logger and adds a prefix to all messages
+    class PrefixedLogger
+      def initialize(logger, prefix)
+        @logger = logger
+        @prefix = prefix
+      end
+
+      def debug(msg)
+        @logger.debug("#{@prefix} #{msg}")
+      end
+
+      def info(msg)
+        @logger.info("#{@prefix} #{msg}")
+      end
+
+      def warn(msg)
+        @logger.warn("#{@prefix} #{msg}")
+      end
+
+      def error(msg)
+        @logger.error("#{@prefix} #{msg}")
+      end
+    end
+
+    module Logging
+      class << self
+        def logger
+          return @logger if @logger
+
+          base_logger = if defined?(Rails)
+                          Rails.logger
+                        else
+                          logger = Logger.new STDOUT
+                          logger.progname = 'Dodgeball::Client'
+                          logger
+                        end
+          @logger = PrefixedLogger.new(base_logger, '[dodgeball-ruby]')
+        end
+
+        attr_writer :logger
+      end
+
+      def self.included(base)
+        class << base
+          def logger
+            Logging.logger
+          end
+        end
+      end
+
+      def logger
+        Logging.logger
+      end
+    end
+  end
+end

data/lib/dodgeball/client/request.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'dodgeball/client/defaults'
+require 'dodgeball/client/utils'
+require 'dodgeball/client/response'
+require 'dodgeball/client/logging'
+require 'dodgeball/client/backoff_policy'
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'pry'
+require 'uri'
+
+module Dodgeball
+  class Client
+    class Request
+      include Dodgeball::Client::Defaults::Request
+      include Dodgeball::Client::Utils
+      include Dodgeball::Client::Logging
+
+      
+      # public: Creates a new request object to send dodgeball api request
+      #
+      def initialize(options = {})
+        options[:host] ||= HOST
+        options[:port] ||= PORT
+
+        options[:ssl] ||= SSL
+
+        @headers = options[:headers] || HEADERS
+        @retries = options[:retries] || RETRIES
+        @backoff_policy =
+          options[:backoff_policy] || Dodgeball::Client::BackoffPolicy.new
+
+        uri = URI(options[:dodgeball_api_url] || DODGEBALL_API_URL)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = options[:ssl]
+        http.read_timeout = DEFAULT_READ_TIMEOUT
+        http.open_timeout = DEFAULT_OPEN_TIMEOUT
+
+        @http = http
+      end
+
+
+      # public: Posts the write key and path to the API.
+      #
+      # returns - Response of the status and error if it exists
+      def post(write_key, path, request_body, request_specific_headers=nil)
+
+       last_response, exception = retry_with_backoff(@retries) do
+          status_code, response_body = send_request(write_key, path, request_body, request_specific_headers)
+          should_retry = should_retry_request?(status_code, response_body)
+          logger.debug("Response status code: #{status_code}")
+          logger.debug("Response response body: #{response_body}") if response_body
+
+          [Response.new(status_code, response_body), should_retry]
+        end
+
+        if exception      
+          logger.error(exception.message)
+          puts "E #{exception.message}"
+          exception.backtrace.each { |line| logger.error(line) }
+          Response.new(-1, exception.to_s)
+        else
+          last_response
+        end
+      end
+
+      private
+
+      def should_retry_request?(status_code, body)
+        if status_code >= 500
+          true # Server error
+        elsif status_code == 429
+          true # Rate limited
+        elsif status_code >= 400
+          logger.error(body)
+          false # Client error. Do not retry, but log
+        else
+          false
+        end
+      end
+
+      # Takes a block that returns [result, should_retry].
+      #
+      # Retries upto `retries_remaining` times, if `should_retry` is false or
+      # an exception is raised. `@backoff_policy` is used to determine the
+      # duration to sleep between attempts
+      #
+      # Returns [last_result, raised_exception]
+      def retry_with_backoff(retries_remaining, &block)
+        result, caught_exception = nil
+        should_retry = false
+
+        begin
+          result, should_retry = yield
+          return [result, nil] unless should_retry
+        rescue StandardError => e
+          should_retry = true
+          caught_exception = e
+        end
+
+        if should_retry && (retries_remaining > 1)
+          logger.debug("Retrying request, #{retries_remaining} retries left")
+          sleep(@backoff_policy.next_interval.to_f / 1000)
+          retry_with_backoff(retries_remaining - 1, &block)
+        else
+          [result, caught_exception]
+        end
+      end
+
+      # Sends a request to the path, returns [status_code, body]
+      def send_request(write_key, path, body, request_specific_headers)
+
+        payload = JSON.generate(body) if body
+        
+        request_headers =(@headers || {}).merge(request_specific_headers || {})
+        request_headers[SECRET_KEY_HEADER] = write_key
+        request = Net::HTTP::Post.new(path, request_headers)
+        
+        if self.class.stub
+          logger.debug "stubbed request to #{path}: " \
+            "write key = #{write_key}, payload = #{payload}"
+
+          [200, '{}']
+        else
+          puts payload
+          response = @http.request(request, payload)
+          [response.code.to_i, response.body]
+        end
+      end
+
+      class << self
+        attr_writer :stub
+
+        def stub
+          @stub || ENV['STUB']
+        end
+      end
+    end
+  end
+end

data/lib/dodgeball/client/response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dodgeball
+  class Client
+    class Response
+      attr_reader :status, :response_body
+
+      # public: Simple class to wrap responses from the API
+      #
+      #
+      def initialize(status = 200, response_body = nil)
+        @status = status
+        @response_body  = response_body
+      end
+    end
+  end
+end

data/lib/dodgeball/client/utils.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Dodgeball
+  class Client
+    module Utils
+      extend self
+
+      # public: Return a new hash with keys converted from strings to symbols
+      #
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(k, v), memo|
+          memo[k.to_sym] = v
+        end
+      end
+
+      # public: Convert hash keys from strings to symbols in place
+      #
+      def symbolize_keys!(hash)
+        hash.replace symbolize_keys hash
+      end
+
+      # public: Return a new hash with keys as strings
+      #
+      def stringify_keys(hash)
+        hash.each_with_object({}) do |(k, v), memo|
+          memo[k.to_s] = v
+        end
+      end
+
+      # public: Returns a new hash with all the date values in the into iso8601
+      #         strings
+      #
+      def isoify_dates(hash)
+        hash.each_with_object({}) do |(k, v), memo|
+          memo[k] = datetime_in_iso8601(v)
+        end
+      end
+
+      # public: Converts all the date values in the into iso8601 strings in place
+      #
+      def isoify_dates!(hash)
+        hash.replace isoify_dates hash
+      end
+
+      # public: Returns a uid string
+      #
+      def uid
+        arr = SecureRandom.random_bytes(16).unpack('NnnnnN')
+        arr[2] = (arr[2] & 0x0fff) | 0x4000
+        arr[3] = (arr[3] & 0x3fff) | 0x8000
+        '%08x-%04x-%04x-%04x-%04x%08x' % arr
+      end
+
+      def datetime_in_iso8601(datetime)
+        case datetime
+        when Time
+          time_in_iso8601 datetime
+        when DateTime
+          time_in_iso8601 datetime.to_time
+        when Date
+          date_in_iso8601 datetime
+        else
+          datetime
+        end
+      end
+
+      def time_in_iso8601(time, fraction_digits = 3)
+        fraction = (('.%06i' % time.usec)[0, fraction_digits + 1] if fraction_digits > 0)
+
+        "#{time.strftime('%Y-%m-%dT%H:%M:%S')}#{fraction}#{formatted_offset(time, true, 'Z')}"
+      end
+
+      def date_in_iso8601(date)
+        date.strftime('%F')
+      end
+
+      def formatted_offset(time, colon = true, alternate_utc_string = nil)
+        time.utc? && alternate_utc_string || seconds_to_utc_offset(time.utc_offset, colon)
+      end
+
+      def seconds_to_utc_offset(seconds, colon = true)
+        (colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON) % [(seconds < 0 ? '-' : '+'), (seconds.abs / 3600), ((seconds.abs % 3600) / 60)]
+      end
+
+      UTC_OFFSET_WITH_COLON = '%s%02d:%02d'
+      UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.sub(':', '')
+    end
+  end
+end

data/lib/dodgeball/client/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dodgeball
+  class Client
+    VERSION = '0.0.1'
+  end
+end

data/lib/dodgeball/client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'uri'
+
+require 'dodgeball/client/version'
+require 'dodgeball/client/defaults'
+require 'dodgeball/client/utils'
+require 'dodgeball/client/request'
+require 'dodgeball/client/response'
+require 'dodgeball/client/logging'
+require 'net/http'
+
+module Dodgeball
+  class Client
+    include Dodgeball::Client::Utils
+    include Dodgeball::Client::Logging
+
+    # @param [Hash] opts
+    # @option opts [String] :write_key Your project's write_key
+    # @option opts [String] :dodgeball_api_url Your Dodgeball API URL
+    # @option opts [Proc] :on_error Handles error calls from the API.
+    # @option opts [Boolean] :ssl Whether to send the call via SSL
+    # @option opts [Boolean] :stub Whether to cause all requests to be stubbed, making it easier to test
+    def initialize(opts = {})
+      symbolize_keys!(opts)
+      Request.stub = opts[:stub] if opts.has_key?(:stub)
+
+      @write_key = opts[:write_key]
+      @dodgeball_api_url = opts[:dodgeball_api_url] || Defaults::Request::DODGEBALL_API_URL
+      uri = URI(opts[:dodgeball_api_url])
+      @host = uri.host
+      @port = uri.port
+      @on_error = opts[:on_error] || proc { |status, error| }
+      @ssl = opts[:ssl] || Defaults::Request::SSL
+
+      check_write_key!
+    end
+
+
+    # Verifies an event and executes a workflow
+    #
+    # @param [Hash] attrs
+    #
+    # @option attrs [Hash] :event Any input to pass to the workflow (required)
+    # @option attrs [String] :source_id Id of the user from the client(required)
+    # @option attrs [Boolean] :sync Direction to the API to return immediately or wait until the workflow returns its first resolution.
+    # @option attrs [String] :verification_id if there was a previous verification executed in the client (optional)
+    def verify(event,source_id,verification_id=nil, sync=true)
+      raise ArgumentError.new('No event provided') unless event
+      raise ArgumentError.new('No source_id provided') unless source_id
+      request_headers={}
+      request_headers[Defaults::Request::SOURCE_ID_HEADER] = source_id
+      request_headers[Defaults::Request::VERIFICATION_ID_HEADER] = verification_id if verification_id
+      body = {event: event, options: {sync: sync}}
+      res=execute_request('verify', body, request_headers)
+      res
+    end
+
+
+    private
+
+    # private: Executes a request with common code to handle results.
+    #
+    def execute_request(request_function, body, request_specific_headers)
+      path=generate_path(request_function)
+      res = Request.new(:dodgeball_api_url => @dodgeball_api_url, :ssl => @ssl).post(@write_key, path, body, request_specific_headers)
+      @on_error.call(res.status, res.response_body) unless res.status == 200
+      res
+    end
+
+    # private: Adds the correct path root
+    #
+    # @param [String] Function name to build into a path
+    def generate_path(request_function)
+      Defaults::Request::PATH_ROOT + request_function
+    end
+
+    # private: Checks that the write_key is properly initialized
+    def check_write_key!
+      raise ArgumentError, 'Write key must be initialized' if @write_key.nil?
+    end
+
+    include Logging
+  end
+end

data/lib/dodgeball.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dodgeball/client'

data/lib/trust-sdk-ruby.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dodgeball'

metadata

@@ -0,0 +1,179 @@
+--- !ruby/object:Gem::Specification
+name: dodgeball-trust-sdk-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dodgeball
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12.2
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.78.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.78.0
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+description: This library provides functionality for Ruby-based server applications
+  to execute no-code workflows from the Dodgeball platform
+email: hello@dodgeballhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dodgeball.rb
+- lib/dodgeball/client.rb
+- lib/dodgeball/client/backoff_policy.rb
+- lib/dodgeball/client/defaults.rb
+- lib/dodgeball/client/logging.rb
+- lib/dodgeball/client/request.rb
+- lib/dodgeball/client/response.rb
+- lib/dodgeball/client/utils.rb
+- lib/dodgeball/client/version.rb
+- lib/trust-sdk-ruby.rb
+homepage: https://github.com/dodgeballhq/dodgeball-trust-sdk-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: The Dodgeball Ruby Server Library
+test_files: []