innox 2.7.6

data/lib/innox/auth/jwt_authenticator.rb

@@ -0,0 +1,127 @@
+require "jwt"
+
+require_relative "error"
+
+module Innox::Auth
+  # JWTAuthenticator used to authenticate user using JWT.
+  #
+  # It allows configuration of JWT verification through following ENV
+  # variables (all optional):
+  # * JWT_ISSUER
+  # * JWT_AUDIENCE
+  # * JWT_ALGORITHM (default: RS256)
+  # * JWT_DEFAULT_LEEWAY
+  # * JWT_ISSUED_AT_LEEWAY
+  # * JWT_EXPIRATION_LEEWAY
+  # * JWT_NOT_BEFORE_LEEWAY
+  #
+  # @see https://github.com/jwt/ruby-jwt JWT validation parameters.
+  #
+  # @example Token validation
+  #   rsa_private = OpenSSL::PKey::RSA.generate(2048)
+  #   rsa_public = rsa_private.public_key
+  #
+  #   payload = {
+  #     iat: Time.now.to_i,
+  #     exp: (Time.now + 60).to_i,
+  #     sub: "session",
+  #     iss: "contour",
+  #     aud: [
+  #       "innox",
+  #       "contour",
+  #     ],
+  #     jti: "BEF5617B7B2762DDE61702F5",
+  #     uid: "TEST123",
+  #     email: "user@example.com",
+  #     role: "admin",
+  #     level: 4,
+  #     state: "active",
+  #   }
+  #
+  #   token = JWT.encode(payload, rsa_private, "RS256")
+  #
+  #   auth = Innox::Auth::JWTAuthenticator.new(rsa_public)
+  #   auth.authenticate!("Bearer #{token}")
+  class JWTAuthenticator
+    # Creates new authenticator with given public key.
+    #
+    # @param public_key [OpenSSL::PKey::PKey] Public key object to verify
+    #   signature.
+    # @param private_key [OpenSSL::PKey::PKey] Optional private key that used
+    #   only to encode new tokens.
+    def initialize(public_key, private_key = nil)
+      @public_key = public_key
+      @private_key = private_key
+
+      @verify_options = {
+        verify_expiration: true,
+        verify_not_before: true,
+        iss: ENV["JWT_ISSUER"],
+        verify_iss: !ENV["JWT_ISSUER"].nil?,
+        verify_iat: true,
+        verify_jti: true,
+        aud: ENV["JWT_AUDIENCE"].to_s.split(",").reject(&:empty?),
+        verify_aud: !ENV["JWT_AUDIENCE"].nil?,
+        sub: "session",
+        verify_sub: true,
+        algorithms: [ENV["JWT_ALGORITHM"] || "RS256"],
+        leeway: ENV["JWT_DEFAULT_LEEWAY"].yield_self { |n| n.to_i unless n.nil? },
+        iat_leeway: ENV["JWT_ISSUED_AT_LEEWAY"].yield_self { |n| n.to_i unless n.nil? },
+        exp_leeway: ENV["JWT_EXPIRATION_LEEWAY"].yield_self { |n| n.to_i unless n.nil? },
+        nbf_leeway: ENV["JWT_NOT_BEFORE_LEEWAY"].yield_self { |n| n.to_i unless n.nil? },
+      }.compact
+
+      @encode_options = {
+        algorithm: @verify_options[:algorithms].first,
+      }.compact
+    end
+
+    # Decodes and verifies JWT.
+    # Returns payload from JWT or raises an exception
+    #
+    # @param token [String] Token string. Must start from <tt>"Bearer "</tt>.
+    # @return [Hash] Payload Hash from JWT without any changes.
+    #
+    # @raise [Innox::Auth::Error] If token is invalid or can't be verified.
+    def authenticate!(token)
+      token_type, token_value = token.to_s.split(" ")
+
+      unless token_type == "Bearer"
+        raise(Innox::Auth::Error, "Token type is not provided or invalid.")
+      end
+
+      decode_and_verify_token(token_value)
+    rescue => error
+      case error
+      when Innox::Auth::Error
+        raise(error)
+      else
+        raise(Innox::Auth::Error, error.message)
+      end
+    end
+
+    # Encodes given payload and produces JWT.
+    #
+    # @param payload [String, Hash] Payload to encode.
+    # @return [String] JWT token string.
+    #
+    # @raise [ArgumentError] If no private key was passed to constructor.
+    def encode(payload)
+      raise(::ArgumentError, "No private key given.") if @private_key.nil?
+
+      JWT.encode(payload, @private_key, @encode_options[:algorithm])
+    end
+
+    private
+
+    def decode_and_verify_token(token)
+      payload, header = JWT.decode(token, @public_key, true, @verify_options)
+
+      payload.keys.each { |k| payload[k.to_sym] = payload.delete(k) }
+
+      payload
+    rescue JWT::DecodeError => e
+      raise(Innox::Auth::Error, "Failed to decode and verify JWT: #{e.message}")
+    end
+  end
+end

data/lib/innox/block.rb

@@ -0,0 +1,27 @@
+module Innox #:nodoc:
+
+  # This class represents blockchain block which contains transactions.
+  #
+  # Using instant of this class in return for Innox::Blockchain#fetch_block!
+  # @see Innox::Blockchain#fetch_block! example implementation
+  # 
+  
+  class Block
+    include Enumerable
+
+    delegate :each, to: :@transactions
+
+    # @!attribute [r] number
+    # return [String] block number
+    attr_reader :number
+
+    # @!attribute [r] transactions
+    # return [Array<Innox::Transaction>]
+    attr_reader :transactions
+
+    def initialize(number, transactions)
+      @number = number
+      @transactions = transactions
+    end
+  end
+end

data/lib/innox/blockchain/abstract.rb

@@ -0,0 +1,159 @@
+module Innox #:nodoc:
+  module Blockchain #:nodoc:
+
+    # @abstract Represents basic blockchain interface.
+    #
+    # Subclass and override abstract methods to implement
+    # a innox plugable blockchain.
+    # Then you need to register your blockchain implementation.
+    #
+    # @see Bitcoin::Blockchain Bitcoin as example of Abstract imlementation
+    #
+    # @example
+    #
+    #   class MyBlockchain < Innox::Abstract::Blockchain
+    #     def fetch_block(block_number)
+    #       # do something
+    #     end
+    #     ...
+    #   end
+    #
+    #   # Register MyBlockchain as innox plugable blockchain.
+    #   Innox::Blockchain.registry[:my_blockchain] = MyBlockchain.new
+    #
+
+    class Abstract
+
+      # Hash of features supported by blockchain.
+      #
+      # @abstract
+      #
+      # @see Abstract::SUPPORTED_FEATURES for list of features supported by innox.
+      #
+      # @!attribute [r] features
+      # @return [Hash] list of features supported by blockchain.
+      attr_reader :features
+
+      # List of features supported by innox.
+      #
+      # @note Features list:
+      #
+      #   case_sensitive - defines if transactions and addresses of current
+      #   blockchain are case_sensitive.
+      #
+      #   cash_addr_format - defines if blockchain supports Cash Address format
+      #   for more info see (https://support.exodus.io/article/664-bitcoin-cash-address-format)
+      SUPPORTED_FEATURES = %i[case_sensitive cash_addr_format].freeze
+
+
+      # Current blockchain settings for performing API calls and building blocks.
+      #
+      # @abstract
+      #
+      # @see Abstract::SUPPORTED_SETTINGS for list of settings required by blockchain.
+      #
+      # @!attribute [r] settings
+      # @return [Hash] current blockchain settings.
+      attr_reader :settings
+
+      # List of configurable settings.
+      #
+      # @see #configure
+      SUPPORTED_SETTINGS = %i[server currencies].freeze
+
+
+      # Abstract constructor.
+      #
+      # @abstract
+      #
+      # @example
+      #   class MyBlockchain < Innox::Abstract::Blockchain
+      #
+      #     DEFAULT_FEATURES = {case_sensitive: true, cash_addr_format: false}.freeze
+      #
+      #     # You could override default features by passing them to initializer.
+      #     def initialize(my_custom_features = {})
+      #       @features = DEFAULT_FEATURES.merge(my_custom_features)
+      #     end
+      #     ...
+      #   end
+      #
+      #   # Register MyBlockchain as innox plugable blockchain.
+      #   custom_features = {cash_addr_format: true}
+      #   Innox::Blockchain.registry[:my_blockchain] = MyBlockchain.new(custom_features)
+      def initialize(*)
+        abstract_method
+      end
+
+      # Merges given configuration parameters with defined during initialization
+      # and returns the result.
+      #
+      # @abstract
+      #
+      # @param [Hash] settings parameters to use.
+      #
+      # @option settings [String] :server Public blockchain API endpoint.
+      # @option settings [Array<Hash>] :currencies List of currency hashes
+      #   with :id,:base_factor,:options(deprecated) keys.
+      #   Custom keys could be added by defining them in Currency #options.
+      #
+      # @return [Hash] merged settings.
+      #
+      # @note Be careful with your blockchain state after configure.
+      #       Clean everything what could be related to other blockchain configuration.
+      #       E.g. client state.
+      def configure(settings = {})
+        abstract_method
+      end
+
+      # Fetches blockchain block by calling API and builds block object
+      # from response payload.
+      #
+      # @abstract
+      #
+      # @param block_number [Integer] the block number.
+      # @return [Innox::Block] the block object.
+      # @raise [Innox::Blockchain::ClientError] if error was raised
+      #   on blockchain API call.
+      def fetch_block!(block_number)
+        abstract_method
+      end
+
+      # Fetches current blockchain height by calling API and returns it as number.
+      #
+      # @abstract
+      #
+      # @return [Integer] the current blockchain height.
+      # @raise [Innox::Blockchain::ClientError] if error was raised
+      #   on blockchain API call.
+      def latest_block_number
+        abstract_method
+      end
+
+      # Fetches address balance of specific currency.
+      #
+      # @note Optional. Don't override this method if your blockchain
+      # doesn't provide functionality to get balance by address.
+      #
+      # @param address [String] the address for requesting balance.
+      # @param currency_id [String] which currency balance we need to request.
+      # @return [BigDecimal] the current address balance.
+      # @raise [Innox::Blockchain::ClientError,Innox::Blockchain::UnavailableAddressBalanceError]
+      # if error was raised on blockchain API call ClientError is raised.
+      # if blockchain API call was successful but we can't detect balance
+      # for address Error is raised.
+      def load_balance_of_address!(address, currency_id)
+        raise Innox::Blockchain::UnavailableAddressBalanceError
+      end
+
+      private
+
+      # Method for defining other methods as abstract.
+      #
+      # @raise [MethodNotImplemented]
+      def abstract_method
+        method_not_implemented
+      end
+    end
+  end
+end

data/lib/innox/blockchain/error.rb

@@ -0,0 +1,37 @@
+module Innox
+  module Blockchain
+    Error = Class.new(StandardError)
+
+    class ClientError < Error
+
+      attr_reader :wrapped_ex
+
+      def initialize(ex_or_string)
+        @wrapped_ex = nil
+
+        if ex_or_string.respond_to?(:backtrace)
+          super(ex_or_string.message)
+          @wrapped_exception = ex_or_string
+        else
+          super(ex_or_string.to_s)
+        end
+      end
+    end
+
+    class MissingSettingError < Error
+      def initialize(key)
+        super "#{key.capitalize} setting is missing"
+      end
+    end
+
+    class UnavailableAddressBalanceError < Error
+      def initialize(address)
+        @address = address
+      end
+
+      def message
+        "Unable to load #{@address} balance"
+      end
+    end
+  end
+end

data/lib/innox/blockchain/registry.rb

@@ -0,0 +1,16 @@
+require "innox/adapter_registry"
+
+module Innox
+  module Blockchain
+
+    VERSION = "1.0.0".freeze
+
+    class << self
+      def registry
+        @registry ||= Registry.new
+      end
+    end
+    class Registry < Innox::AdapterRegistry
+    end
+  end
+end

data/lib/innox/command/base.rb

@@ -0,0 +1,11 @@
+module Innox::Command
+  class Base < Clamp::Command
+    def say(str)
+      puts str
+    end
+
+    def sql_client
+      @sql_client ||= Innox::Sql::Client.new.connect
+    end
+  end
+end

data/lib/innox/command/db.rb

@@ -0,0 +1,20 @@
+module Innox::Command::DB
+  class Create < Innox::Command::Base
+    def execute
+      client = Innox::Sql::Client.new
+      database_name = client.config.delete(:database)
+      Innox::Sql::Schema.new(client.connect).create_database(database_name)
+    end
+  end
+
+  class Migrate < Innox::Command::Base
+    def execute
+      Innox::Sql::Schema.new(sql_client).create_tables
+    end
+  end
+
+  class Root < Innox::Command::Base
+    subcommand "create", "Create database", Innox::Command::DB::Create
+    subcommand "migrate", "Create tables", Innox::Command::DB::Migrate
+  end
+end

data/lib/innox/command/inject.rb

@@ -0,0 +1,13 @@
+module Innox::Command
+  class Inject < Innox::Command::Base
+    class InnoxEvents < Innox::Command::Base
+      option ["-e", "--exchange"], "NAME", "exchange name to inject messages to", default: "innox.events.ranger"
+      def execute
+        Innox::Logger.logger.level = :debug
+        Innox::Injectors::InnoxEvents.new.run!(exchange)
+      end
+    end
+
+    subcommand "innox_events", "Inject innox events in mq", InnoxEvents
+  end
+end

data/lib/innox/command/root.rb

@@ -0,0 +1,14 @@
+require "innox/command/base"
+require "innox/command/service"
+require "innox/command/db"
+require "innox/command/inject"
+require "innox/command/security"
+
+module Innox
+  class Root < Command::Base
+    subcommand "db", "Database related sub-commands", Innox::Command::DB::Root
+    subcommand "service", "Services management related sub-commands", Innox::Command::Service::Root
+    subcommand "inject", "Data injectors", Innox::Command::Inject
+    subcommand "security", "Security management related sub-commands", Innox::Command::Security
+  end
+end

data/lib/innox/command/security.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Innox::Command
+  class Security < Innox::Command::Base
+    class KeyGenerator < Innox::Command::Base
+      option "--print", :flag, "print on screen"
+      option "--path", "FOLDER", "save keypair into folder", default: "secrets"
+
+      def execute
+        keypair = Innox::Security::KeyGenerator.new
+
+        if print?
+          puts keypair.private, keypair.public
+          puts "-----BASE64 ENCODED-----"
+          puts Base64.urlsafe_encode64(keypair.public)
+        else
+          begin
+            keypair.save(path)
+            puts "Files saved in #{File.join(path, 'rsa-key')}"
+          rescue IOError => e
+            abort("Failed saving files")
+          end
+        end
+      end
+    end
+
+    subcommand "keygen", "Generate a public private rsa key pair", KeyGenerator
+  end
+end

data/lib/innox/command/service.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Innox::Command::Service
+  class Start < Innox::Command::Base
+    class Ranger < Innox::Command::Base
+      option ["-e", "--exchange"], "NAME", "exchange name to inject messages to", default: "innox.events.ranger"
+      option "--[no-]stats", :flag, "display periodically connections statistics", default: true
+      option "--stats-period", "SECONDS", "period of displaying stats in seconds", default: 30
+      def execute
+        raise ArgumentError, "JWT_PUBLIC_KEY was not specified." if ENV["JWT_PUBLIC_KEY"].to_s.empty?
+
+        key_decoded = Base64.urlsafe_decode64(ENV["JWT_PUBLIC_KEY"])
+
+        jwt_public_key = OpenSSL::PKey.read(key_decoded)
+        if jwt_public_key.private?
+          raise ArgumentError, "JWT_PUBLIC_KEY was set to private key, however it should be public."
+        end
+
+        raise "stats period missing" if stats? && !stats_period
+
+        Prometheus::Client.config.data_store = Prometheus::Client::DataStores::SingleThreaded.new()
+        registry = Prometheus::Client.registry
+
+        opts = {
+          display_stats: stats?,
+          stats_period:  stats_period.to_f,
+          metrics_port:  8082,
+          registry:      registry
+        }
+        ::Innox::Ranger.run!(jwt_public_key, exchange, opts)
+      end
+    end
+
+    subcommand "ranger", "Start ranger process", Ranger
+  end
+
+  class Root < Innox::Command::Base
+    subcommand "start", "Start a service", Start
+  end
+end

data/lib/innox/error.rb

@@ -0,0 +1,18 @@
+class Innox::Error < ::StandardError
+  @@default_code = 2000
+
+  attr :code, :text
+
+  def initialize(opts = {})
+    @code = opts[:code] || @@default_code
+    @text = opts[:text] || ""
+
+    @message = {error: {code: @code, message: @text}}
+
+    if @text != ""
+      super("#{@code}: #{text}")
+    else
+      super("#{@code}")
+    end
+  end
+end

data/lib/innox/executor.rb

@@ -0,0 +1,64 @@
+require "mysql2"
+require "benchmark"
+
+client = Mysql2::Client.new(
+    host: "172.19.0.3",
+    username: "root",
+    password: "changeme",
+    port: 3306,
+    database: "innox_development")
+
+queries = [
+    "INSERT INTO `trades` (`ask_id`, `ask_member_id`, `bid_id`, `bid_member_id`, `price`, `volume`, `funds`, `market_id`, `trend`, `created_at`, `updated_at`) VALUES (18711, 81, 18708, 82, 0.99999999, 50.0, 49.9999995, 'eurusd', 0, NOW(), NOW())",
+    "UPDATE `accounts` SET `accounts`.`locked` = 3571.09999702 WHERE `accounts`.`id` = 164",
+    "UPDATE `accounts` SET `accounts`.`balance` = 999995119.5335 WHERE `accounts`.`id` = 163",
+    "UPDATE `accounts` SET `accounts`.`locked` = 4257.0 WHERE `accounts`.`id` = 161",
+    "UPDATE `accounts` SET `accounts`.`balance` = 999995825.720262199325 WHERE `accounts`.`id` = 162",
+    "UPDATE `orders` SET `volume` = 20.0, `locked` = 19.9999998, `funds_received` = 53.0, `trades_count` = 2, `updated_at` = '2018-06-25 23:44:37' WHERE `orders`.`id` = 18708",
+    "UPDATE `orders` SET `volume` = 0.0, `locked` = 0.0, `funds_received` = 78.59999924, `trades_count` = 2, `state` = 200, `updated_at` = '2018-06-25 23:44:37' WHERE `orders`.`id` = 18711"
+]
+
+puts Benchmark.measure {
+    1_000.times {
+
+        client.query("begin")
+        begin
+
+            100.times {
+                queries.each do |q|
+                    client.query q
+                end
+            }
+
+        rescue Mysql2::Error => e
+            puts "+++++++ DB ERROR - ROLLING BACK ++++++++"
+            puts e
+            client.query("rollback")
+            exit
+        end
+        client.query("commit") #commit the changes to the DB
+
+    }
+}
+
+client.close
+
+__END__
+
+require 'mysql2/em'
+
+EM.run do
+   client = Mysql2::EM::Client.new(
+        :host => '172.19.0.3',
+        :username => 'root',
+        :password => 'changeme',
+        :port => 3306,
+        :database => 'innox_development')
+
+
+    defer1 = client.query "SELECT sleep(3) as first_query"
+    defer1.callback do |result|
+        puts "Result: #{result.to_a.inspect}"
+    end
+
+end