straight-server 0.1.0

data/lib/straight-server/gateway.rb

@@ -0,0 +1,260 @@
+module StraightServer
+
+  # This module contains common features of Gateway, later to be included
+  # in one of the classes below.
+  module GatewayModule
+
+    class InvalidSignature           < Exception; end
+    class InvalidOrderId             < Exception; end
+    class CallbackUrlBadResponse     < Exception; end
+    class WebsocketExists            < Exception; end
+    class WebsocketForCompletedOrder < Exception; end
+
+    CALLBACK_URL_ATTEMPT_TIMEFRAME = 3600 # seconds
+
+    def initialize(*attrs)
+      
+      # When the status of an order changes, we send an http request to the callback_url
+      # and also notify a websocket client (if present, of course).
+      @order_callbacks     = [
+        lambda do |order|
+          StraightServer::Thread.new do
+            send_callback_http_request     order
+            send_order_to_websocket_client order
+          end
+        end
+      ]
+
+      @blockchain_adapters = [
+        Straight::Blockchain::BlockchainInfoAdapter.mainnet_adapter,
+        Straight::Blockchain::HelloblockIoAdapter.mainnet_adapter
+      ]
+
+      @exchange_rate_adapters = []
+      @status_check_schedule = Straight::GatewayModule::DEFAULT_STATUS_CHECK_SCHEDULE
+      @websockets            = {}
+
+      super
+      initialize_exchange_rate_adapters # should always go after super
+    end
+    
+    # Creates a new order and saves into the DB. Checks if the MD5 hash
+    # is correct first.
+    def create_order(attrs={})
+      StraightServer.logger.info "Creating new order with attrs: #{attrs}"
+      signature = attrs.delete(:signature)
+      raise InvalidOrderId if check_signature && (attrs[:id].nil? || attrs[:id].to_i <= 0)
+      if !check_signature || sign_with_secret(attrs[:id]) == signature
+        order = order_for_keychain_id(
+          amount:           attrs[:amount],
+          keychain_id:      increment_last_keychain_id!,
+          currency:         attrs[:currency],
+          btc_denomination: attrs[:btc_denomination]
+        )
+        order.id         = attrs[:id].to_i if attrs[:id]
+        order.data       = attrs[:data]    if attrs[:data]
+        order.gateway    = self
+        order.save
+        self.save
+        StraightServer.logger.info "Order #{order.id} created: #{order.to_h}"
+        order
+      else
+        StraightServer.logger.warn "Invalid signature, cannot create an order for gateway (#{id})"
+        raise InvalidSignature
+      end
+    end
+
+    # Used to track the current keychain_id number, which is used by
+    # Straight::Gateway to generate addresses from the pubkey. The number is supposed
+    # to be incremented by 1. In the case of a Config file type of Gateway, the value
+    # is stored in a file in the .straight directory.
+    def increment_last_keychain_id!
+      self.last_keychain_id += 1
+      self.save
+      self.last_keychain_id
+    end
+
+    def add_websocket_for_order(ws, order)
+      raise WebsocketExists            unless @websockets[order.id].nil?
+      raise WebsocketForCompletedOrder unless order.status < 2
+      StraightServer.logger.info "Opening ws connection for #{order.id}"
+      ws.on(:close) do |event|
+        @websockets.delete(order.id)
+        StraightServer.logger.info "Closing ws connection for #{order.id}"
+      end
+      @websockets[order.id] = ws
+      ws
+    end
+
+    def send_order_to_websocket_client(order)
+      if ws = @websockets[order.id]
+        ws.send(order.to_json)
+        ws.close
+      end
+    end
+
+    def initialize_exchange_rate_adapters
+      if self.exchange_rate_adapter_names
+        self.exchange_rate_adapter_names.each do |adapter|
+          begin
+            @exchange_rate_adapters << Kernel.const_get("Straight::ExchangeRate::#{adapter}Adapter").new
+          rescue NameError 
+            raise NameError, "No such adapter exists: Straight::ExchangeRate::#{adapter}Adapter"
+          end
+        end
+      end
+    end
+
+    private
+
+      def sign_with_secret(content, level: 1)
+        result = content.to_s
+        level.times do
+          h = HMAC::SHA1.new(secret)
+          h << result
+          result = h.hexdigest
+        end
+        result
+      end
+
+      # Tries to send a callback HTTP request to the resource specified
+      # in the #callback_url. If it fails for any reason, it keeps trying for an hour (3600 seconds)
+      # making 10 http requests, each delayed by twice the time the previous one was delayed.
+      # This method is supposed to be running in a separate thread.
+      def send_callback_http_request(order, delay: 5)
+        return if callback_url.nil?
+
+        StraightServer.logger.info "Attempting to send request to the callback url for order #{order.id} to #{callback_url}..."
+
+        # Composing the request uri here
+        signature = self.check_signature ? "&signature=#{sign_with_secret(order.id, level: 2)}" : ''
+        data      = order.data           ? "&data=#{order.data}"                                : ''
+        uri       = URI.parse(callback_url + '?' + order.to_http_params + signature + data)
+
+        begin
+          response = Net::HTTP.get_response(uri)
+          order.callback_response = { code: response.code, body: response.body }
+          order.save
+          raise CallbackUrlBadResponse unless response.code.to_i == 200
+        rescue Exception => e
+          if delay < CALLBACK_URL_ATTEMPT_TIMEFRAME
+            sleep(delay)
+            send_callback_http_request(order, delay: delay*2)
+          else
+            StraightServer.logger.warn "Callback request for order #{order.id} faile, see order's #callback_response field for details"
+          end
+        end
+        
+        StraightServer.logger.info "Callback request for order #{order.id} performed successfully"
+      end
+
+  end
+
+  # Uses database to load and save attributes
+  class GatewayOnDB < Sequel::Model(:gateways)
+
+    include Straight::GatewayModule
+    include GatewayModule
+    plugin :timestamps, create: :created_at, update: :updated_at
+    plugin :serialization, :marshal, :exchange_rate_adapter_names
+
+  end
+
+  # Uses a config file to load attributes and a special _last_keychain_id file
+  # to store last_keychain_id
+  class GatewayOnConfig
+
+    include Straight::GatewayModule
+    include GatewayModule
+
+    # This is the key that allows users (those, who use the gateway,
+    # online stores, for instance) to connect and create orders.
+    # It is not used directly, but is mixed with all the params being sent
+    # and a MD5 hash is calculted. Then the gateway checks whether the
+    # MD5 hash is correct.
+    attr_accessor :secret
+
+    # This is used to generate the next address to accept payments
+    attr_accessor :last_keychain_id
+
+    # If set to false, doesn't require an unique id of the order along with
+    # the signed md5 hash of that id + secret to be passed into the #create_order method.
+    attr_accessor :check_signature
+
+    # A url to which the gateway will send an HTTP request with the status of the order data
+    # (in JSON) when the status of the order is changed. The response should always be 200,
+    # otherwise the gateway will awesome something went wrong and will keep trying to send requests
+    # to this url according to a specific shedule.
+    attr_accessor :callback_url
+
+    # This will be assigned the number that is the order in which this gateway follows in
+    # the config file.
+    attr_accessor :id
+
+    attr_accessor :exchange_rate_adapter_names
+
+    # Because this is a config based gateway, we only save last_keychain_id
+    # and nothing more.
+    def save
+      File.open(@last_keychain_id_file, 'w') {|f| f.write(last_keychain_id) }
+    end
+
+    # Loads last_keychain_id from a file in the .straight dir.
+    # If the file doesn't exist, we create it. Later, whenever an attribute is updated,
+    # we save it to the file.
+    def load_last_keychain_id!
+      @last_keychain_id_file = StraightServer::Initializer::STRAIGHT_CONFIG_PATH +
+                               "/#{name}_last_keychain_id"
+      if File.exists?(@last_keychain_id_file)
+        self.last_keychain_id = File.read(@last_keychain_id_file).to_i
+      else
+        self.last_keychain_id = 0
+        save
+      end
+    end
+
+    # This will later be used in the #find_by_id. Because we don't use a DB,
+    # the id will actually be the index of an element in this Array. Thus,
+    # the order in which gateways follow in the config file is important.
+    @@gateways = []
+
+    # Create instances of Gateway by reading attributes from Config
+    i = 0
+    StraightServer::Config.gateways.each do |name, attrs|
+      i += 1
+      gateway = self.new
+      gateway.pubkey                 = attrs['pubkey']
+      gateway.confirmations_required = attrs['confirmations_required'].to_i
+      gateway.order_class            = attrs['order_class']
+      gateway.secret                 = attrs['secret']
+      gateway.check_signature        = attrs['check_signature']
+      gateway.callback_url           = attrs['callback_url']
+      gateway.default_currency       = attrs['default_currency']
+      gateway.name                   = name
+      gateway.id                     = i
+      gateway.exchange_rate_adapter_names = attrs['exchange_rate_adapters']
+      gateway.initialize_exchange_rate_adapters
+      gateway.load_last_keychain_id!
+      @@gateways << gateway
+    end
+    
+
+    # This method is a replacement for the Sequel's model one used in DB version of the gateway
+    # and it finds gateways using the index of @@gateways Array.
+    def self.find_by_id(id)
+      @@gateways[id.to_i-1]
+    end
+
+  end
+
+  # It may not be a perfect way to implement such a thing, but it gives enough flexibility to people
+  # so they can simply start using a single gateway on their machines, a gateway which attributes are defined
+  # in a config file instead of a DB. That way they don't need special tools to access the DB and create
+  # a gateway, but can simply edit the config file.
+  Gateway = if StraightServer::Config.gateways_source = 'config'
+    GatewayOnConfig
+  else
+    GatewayOnDB
+  end
+
+end

data/lib/straight-server/initializer.rb

@@ -0,0 +1,78 @@
+module StraightServer
+
+  module Initializer
+
+    GEM_ROOT             = File.expand_path('../..', File.dirname(__FILE__))
+    STRAIGHT_CONFIG_PATH = ENV['HOME'] + '/.straight'
+
+    def prepare
+      create_config_file unless File.exist?(STRAIGHT_CONFIG_PATH + '/config.yml')
+      read_config_file
+      create_logger
+      connect_to_db
+      run_migrations if migrations_pending?
+    end
+
+    private
+
+      def create_config_file
+        puts "\e[1;33mWARNING!\e[0m \e[33mNo file ~/.straight/config was found. Created a sample one for you.\e[0m"
+        puts "You should edit it and try starting the server again.\n"
+
+        FileUtils.mkdir_p(STRAIGHT_CONFIG_PATH) unless File.exist?(STRAIGHT_CONFIG_PATH)
+        FileUtils.cp(GEM_ROOT + '/templates/config.yml', ENV['HOME'] + '/.straight/') 
+        puts "Shutting down now.\n\n"
+        exit
+      end
+
+      def read_config_file
+        YAML.load_file(STRAIGHT_CONFIG_PATH + '/config.yml').each do |k,v|
+          StraightServer::Config.send(k + '=', v)
+        end
+      end
+
+      def connect_to_db
+
+        # symbolize keys for convenience
+        db_config = StraightServer::Config.db.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+        db_name = if db_config[:adapter] == 'sqlite'
+          STRAIGHT_CONFIG_PATH + "/" + db_config[:name]
+        else
+          db_config[:name]
+        end
+
+        StraightServer.db_connection = Sequel.connect(
+          "#{db_config[:adapter]}://"                                                   +
+          "#{db_config[:user]}#{(":" if db_config[:user])}"                             +
+          "#{db_config[:password]}#{("@" if db_config[:user] || db_config[:password])}" +
+          "#{db_config[:host]}#{(":" if db_config[:port])}"                             +
+          "#{db_config[:port]}#{("/" if db_config[:host] || db_config[:port])}"         +
+          "#{db_name}"
+        )
+      end
+
+      def run_migrations
+        print "\nPending migrations for the database detected. Migrating..."
+        Sequel::Migrator.run(StraightServer.db_connection, GEM_ROOT + '/db/migrations/')
+        print "done\n\n"
+      end
+
+      def migrations_pending?
+        !Sequel::Migrator.is_current?(StraightServer.db_connection, GEM_ROOT + '/db/migrations/')
+      end
+
+      def create_logger
+        require_relative 'logger'
+        StraightServer.logger = StraightServer::Logger.new(
+          log_level:       ::Logger.const_get(Config.logmaster['log_level'].upcase),
+          file:            STRAIGHT_CONFIG_PATH + '/' + Config.logmaster['file'],
+          raise_exception: Config.logmaster['raise_exception'],
+          name:            Config.logmaster['name'],
+          email_config:    Config.logmaster['email_config']
+        )
+      end
+
+  end
+
+end

data/lib/straight-server/logger.rb

@@ -0,0 +1,18 @@
+module StraightServer
+  class Logger < Logmaster
+
+    # inserts a number of blank lines
+    def blank_lines(n=1)
+
+      n.times { puts "\n" }
+
+      File.open(StraightServer::Initializer::STRAIGHT_CONFIG_PATH + '/' + Config.logmaster['file'], 'a') do |f|
+        n.times do
+          f.puts "\n"
+        end
+      end if Config.logmaster['file']
+
+    end
+
+  end
+end

data/lib/straight-server/order.rb

@@ -0,0 +1,62 @@
+module StraightServer
+ 
+  class Order < Sequel::Model 
+
+    include Straight::OrderModule
+    plugin :validation_helpers
+    plugin :timestamps, create: :created_at, update: :updated_at
+
+    plugin :serialization
+    serialize_attributes :marshal, :callback_response
+
+    def gateway
+      @gateway ||= Gateway.find_by_id(gateway_id)
+    end
+    
+    def gateway=(g)
+      self.gateway_id = g.id
+      @gateway        = g
+    end
+
+    def save
+      super # calling Sequel::Model save
+      @status_changed = false
+    end
+
+    def status_changed?
+      @status_changed
+    end
+
+    def to_h
+      super.merge({ id: id })
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    def validate
+      super # calling Sequel::Model validator
+      errors.add(:amount,     "is invalid") if !amount.kind_of?(Numeric)     || amount <= 0
+      errors.add(:gateway_id, "is invalid") if !gateway_id.kind_of?(Numeric) || gateway_id <= 0
+      validates_unique   :id, :address, [:keychain_id, :gateway_id]
+      validates_presence [:address, :keychain_id, :gateway_id, :amount]
+    end
+
+    def to_http_params
+      "order_id=#{id}&amount=#{amount}&status=#{status}&address=#{address}&tid=#{tid}"
+    end
+
+    def start_periodic_status_check
+      StraightServer.logger.info "Starting periodic status checks of the order #{self.id}"
+      super
+    end
+
+    def check_status_on_schedule(period: 10, iteration_index: 0)
+      StraightServer.logger.info "Checking status of order #{self.id}"
+      super
+    end
+
+  end
+
+end

data/lib/straight-server/orders_controller.rb

@@ -0,0 +1,86 @@
+module StraightServer
+
+  class OrdersController
+
+    attr_reader :response
+
+    def initialize(env)
+      @env          = env
+      @params       = env.params
+      @method       = env['REQUEST_METHOD']
+      @request_path = env['REQUEST_PATH'].split('/').delete_if { |s| s.nil? || s.empty? }
+      dispatch
+    end
+
+    def create
+      begin
+        order = @gateway.create_order(
+          amount:           @params['amount'],
+          currency:         @params['currency'],
+          btc_denomination: @params['btc_denomination'],
+          id:               @params['order_id'],
+          signature:        @params['signature']
+        )
+        StraightServer::Thread.new do
+          order.start_periodic_status_check
+        end
+        [200, {}, order.to_json ]
+      rescue Sequel::ValidationFailed => e
+        StraightServer.logger.warn "validation errors in order, cannot create it."
+        [409, {}, "Invalid order: #{e.message}" ]
+      rescue StraightServer::GatewayModule::InvalidSignature
+        [409, {}, "Invalid signature for id: #{@params['order_id']}" ]
+      rescue StraightServer::GatewayModule::InvalidOrderId
+        StraightServer.logger.warn message = "An invalid id for order supplied: #{@params['order_id']}"
+        [409, {}, message ]
+      end
+    end
+
+    def show
+      order = Order[@params['id']]
+      if order
+        order.status(reload: true)
+        order.save if order.status_changed?
+        [200, {}, order.to_json]
+      end
+    end
+
+    def websocket
+      order = Order[@params['id']]
+      if order
+        begin
+          @gateway.add_websocket_for_order ws = Faye::WebSocket.new(@env), order
+          ws.rack_response
+        rescue Gateway::WebsocketExists
+          [403, {}, "Someone is already listening to that order"]
+        rescue Gateway::WebsocketForCompletedOrder
+          [403, {}, "You cannot listen to this order because it is completed (status > 1)"]
+        end
+      end
+    end
+
+    private
+
+      def dispatch
+        
+        StraightServer.logger.blank_lines
+        StraightServer.logger.info "#{@method} #{@env['REQUEST_PATH']}\n#{@params}"
+
+        @gateway = StraightServer::Gateway.find_by_id(@request_path[1])
+
+        @response = if @request_path[3] # if an order id is supplied
+          @params['id'] = @request_path[3].to_i
+          if @request_path[4] == 'websocket'
+            websocket
+          elsif @request_path[4].nil? && @method == 'GET'
+            show
+          end
+        elsif @request_path[3].nil?# && @method == 'POST'
+          create
+        end
+        @response = [404, {}, "#{@method} /#{@request_path.join('/')} Not found"] if @response.nil? 
+      end
+
+  end
+
+end

data/lib/straight-server/server.rb

@@ -0,0 +1,52 @@
+module StraightServer
+  class Server < Goliath::API
+
+    use Goliath::Rack::Params
+    include StraightServer::Initializer
+    Faye::WebSocket.load_adapter('goliath')
+
+    def initialize
+      prepare
+      StraightServer.logger.info "Starting Straight server v #{StraightServer::VERSION}"
+      require_relative 'order'
+      require_relative 'gateway'
+      require_relative 'orders_controller'
+      super
+    end
+
+    def response(env)
+      # POST /gateways/1/orders   - create order
+      # GET  /gateways/1/orders/1 - see order info
+      #      /gateways/1/orders/1/websocket - subscribe to order status changes via a websocket
+
+      # This will be more complicated in the future. For now it
+      # just checks that the path starts with /gateways/:id/orders
+
+      StraightServer.logger.watch_exceptions do
+
+        # This is a client implementation example, an html page + a dart script
+        # supposed to only be loaded in development.
+        if Goliath.env == :development
+          if env['REQUEST_PATH'] == '/'
+            return [200, {}, IO.read(Initializer::GEM_ROOT + '/examples/client/client.html')]
+          elsif Goliath.env == :development && env['REQUEST_PATH'] == '/client.dart'
+            return [200, {}, IO.read(Initializer::GEM_ROOT + '/examples/client/client.dart')]
+          end
+        end
+
+        if env['REQUEST_PATH'] =~ /\A\/gateways\/.+?\/orders(\/.+)?\Z/
+          controller = OrdersController.new(env)
+          return controller.response
+        else
+          return [404, {}, "#{env['REQUEST_METHOD']} #{env['REQUEST_PATH']} Not found"]
+        end
+
+      end
+
+      # Assume things went wrong, if they didn't go right
+      [500, {}, "#{env['REQUEST_METHOD']} #{env['REQUEST_PATH']} Server Error"]
+
+    end
+    
+  end
+end

data/lib/straight-server/thread.rb

@@ -0,0 +1,9 @@
+module StraightServer
+
+  class Thread
+    def self.new(&block)
+      ::Thread.new(&block)
+    end
+  end
+
+end

data/lib/straight-server.rb

@@ -0,0 +1,25 @@
+require 'yaml'
+require 'json'
+require 'sequel'
+require 'straight'
+require 'logmaster'
+require 'hmac'
+require 'hmac-sha1'
+require 'net/http'
+require 'faye/websocket'
+Sequel.extension :migration
+
+require_relative 'straight-server/config'
+require_relative 'straight-server/initializer'
+require_relative 'straight-server/thread'
+require_relative 'straight-server/orders_controller'
+
+module StraightServer
+
+  VERSION = '0.1.0'
+
+  class << self
+    attr_accessor :db_connection, :logger
+  end
+
+end

data/spec/.straight/config.yml

@@ -0,0 +1,34 @@
+# If set to db, then use DB table to store gateways,
+# useful when your run many gateways on the same server.
+gateways_source: config
+
+gateways:
+
+  default:
+    pubkey: 'xpub-000'
+    confirmations_required: 0
+    order_class: "StraightServer::Order"
+    secret: 'secret'
+    check_signature: true
+    callback_url: 'http://localhost:3000/payment-callback'
+    default_currency: 'BTC'
+    exchange_rate_adapters:
+      - Bitpay
+      - Coinbase
+      - Bitstamp
+  second_gateway:
+    pubkey: 'xpub-001'
+    confirmations_required: 0
+    order_class: "StraightServer::Order"
+    secret: 'secret'
+    check_signature: false
+    callback_url: 'http://localhost:3001/payment-callback'
+    default_currency: 'BTC'
+    exchange_rate_adapters:
+      - Bitpay
+      - Coinbase
+      - Bitstamp
+
+db:
+  adapter: sqlite
+  name: straight.db

data/spec/factories.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  
+  factory :order, class: StraightServer::Order do
+    sequence(:id)          { |i| i }
+    sequence(:keychain_id) { |i| i }
+    sequence(:address)     { |i| "address_#{i}" }
+    amount 10
+    gateway_id 1
+  end
+
+end