oanda_api_v20 1.5.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b8108f8ae8240196afbf5ce81fb7cc96f9eeece1
-  data.tar.gz: 97384a79da9a3a293529034eb5f2a483c5c9b96e
+SHA256:
+  metadata.gz: be0ef34e9d27b283681c25c8f281c5ec264f9b36b63b39715df9bc69de0209a9
+  data.tar.gz: ba7a3cd6ec27e820e58565fedc2ec6b7e723f954ae1381ef79548d4ca88469af
 SHA512:
-  metadata.gz: def31bfcd6716e880495a6396133334fd649c9fa64f42c1b957b4a165bb7b3b3ea74e13be95b3293ababb1f754ad935bd09ab24360ee9a58008e646bd61279f7
-  data.tar.gz: 6ee7cb2047dd8e05eae5da2da3efd859a6dfad1fd1c4f989342b73a9a67e6bd43d8b6145991e1c73ab0c82e6d61a7e94a2ae7679d049af52e0a4a6855c496c1a
+  metadata.gz: 39f4320e897a343a542e19155c36a6b80698ab7b57bc8d5e40da608ab6ec6845ba12cf9d1a79ef29c24a28850616ddf12760929fc15f78df7b9ff7aa5ea41eb3
+  data.tar.gz: e791adff74088c1f6da6a23454f30d13fe226828a9683d609b9ff910819a34008722a4badb6b0d7b29fb0b59b95064f5eb44844b2474a6004877c46d1f0f8dec

data/.gitignore

@@ -1,3 +1,4 @@
 .byebug_history
 oanda_api_v20-*.gem
 Gemfile.lock
+.DS_Store

data/.ruby-version

@@ -1 +1 @@
-2.3.1
+2.7.2

data/.travis.yml

@@ -1,3 +1,7 @@
 language: ruby
 rvm:
-  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - jruby-9.2.5.0

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Change Log
 
+## 2.2.0
+#### 2021-08-27
+
+* New transactions_stream endpoint. Big thanks to @plabaj.
+* Upgraded development dependency version for rake to fix potential security vulnerability.
+
+## 2.1.1
+#### 2019-10-05
+* Fix to pricing_stream method. This fixes the currency pair rate being reused over and over no matter the value read in the HTTP chunk. Big thanks to @joseluis-fw & @salrepe.
+
+## 2.1.0
+#### 2019-02-01
+* New pricing_stream endpoint. Big thanks to @joseluis-fw.
+* Raises an OandaApiV20::ParseError exception when a malformed response returned from Oanda API.
+* The OandaApiV20::RequestError exception object now has an original_exception attribute which contains the original exception object raised.
+
+## 2.0.0
+#### 2018-04-24
+* Fixed issues when trying to reuse a Client object to make HTTP requests to Oanda.
+* Moved instance variables last_action, last_arguments, instrument and account_id from the Client class to the Api class. They should not be part of a Client object.
+* Removed last_transaction_id instance variable.
+* RubyVM::Logger changed to ::Logger.
+* Added a connection_pool_size option to allow persistent HTTP connection control on the Client object.
+* Added a max_requests_per_second option to allow customized control on the Client max requests per second allowed to Oanda API.
+* Added multithreading support for HTTP request governing. HTTP requests will be correctly allocated across multiple client threads.
+* Raises an OandaApiV20::ApiError exception when no client object was supplied when instantiating an OandaApiV20::Api instance.
+
 ## 1.5.0
 #### 2017-07-07
 * Updated the orders method to allow query options to be passed along.

data/README.md

@@ -33,10 +33,22 @@ If you would like to trade with your test account:
 
     client = OandaApiV20.new(access_token: 'my_access_token', practice: true)
 
+If you would like to use the streaming endpoints:
+
+    client = OandaApiV20.new(access_token: 'my_access_token', stream: true)
+
 If you need your requests to go through a proxy:
 
     client = OandaApiV20.new(access_token: 'my_access_token', proxy_url: 'https://user:pass@proxy.com:80')
 
+You can adjust the persistend connection pool size, the default is 2:
+
+    client = OandaApiV20.new(access_token: 'my_access_token', connection_pool_size: 10)
+
+You can adjust the number of requests per second allowed to Oanda API, the default is 100:
+
+    client = OandaApiV20.new(access_token: 'my_access_token', max_requests_per_second: 10)
+
 ## Examples
 
 ### Accounts
@@ -63,10 +75,6 @@ client.account('account_id').instruments.show
 client.account('account_id').instruments('EUR_USD,EUR_CAD').show
 ```
 
-```ruby
-client.account('account_id').changes.show
-```
-
 ```ruby
 options = { 'sinceTransactionID' => '6358' }
 
@@ -103,6 +111,10 @@ options = { 'instrument' => 'USD_CAD' }
 client.account('account_id').orders(options).show
 ```
 
+```ruby
+client.account('account_id').pending_orders.show
+```
+
 ```ruby
 id = client.account('account_id').orders.show['orders'][0]['id']
 
@@ -128,10 +140,12 @@ id = client.account('account_id').orders.show['orders'][0]['id']
 
 options = {
   'order' => {
+    'instrument' => 'EUR_CAD',
+    'price' => '1.6000',
     'timeInForce' => 'GTC',
-    'price' => '1.7000',
-    'type' => 'TAKE_PROFIT',
-    'tradeID' => '1'
+    'type' => 'MARKET_IF_TOUCHED',
+    'units' => '200',
+    'positionFill' => 'DEFAULT'
   }
 }
 
@@ -182,11 +196,11 @@ id = client.account('account_id').open_trades.show['trades'][0]['id']
 options = {
   'takeProfit' => {
     'timeInForce' => 'GTC',
-    'price' => '0.5'
+    'price' => '2.5'
   },
   'stopLoss' => {
     'timeInForce' => 'GTC',
-    'price' => '2.5'
+    'price' => '0.5'
   }
 }
 
@@ -283,6 +297,14 @@ options = {
 client.account('account_id').transactions_since_id(options).show
 ```
 
+```ruby
+client = OandaApiV20.new(access_token: 'my_access_token', stream: true)
+
+client.account('account_id').transactions_stream.show do |json|
+  puts json if json['type'] != 'HEARTBEAT'
+end
+```
+
 ### Pricing
 
 See the [Oanda Documentation](http://developer.oanda.com/rest-live-v20/pricing-ep/) for all available options on pricing.
@@ -295,10 +317,34 @@ options = {
 client.account('account_id').pricing(options).show
 ```
 
+```ruby
+client = OandaApiV20.new(access_token: 'my_access_token', stream: true)
+
+options = {
+  'instruments' => 'EUR_USD,USD_CAD'
+}
+
+client.account('account_id').pricing_stream(options).show do |json|
+  puts json if json['type'] == 'PRICE'
+end
+```
+
 ## Exceptions
 
+A `OandaApiV20::ParseError` will be raised when a response from the Oanda API is malformed.
+
 A `OandaApiV20::RequestError` will be raised when a request to the Oanda API failed for any reason.
 
+You can access the original exception in a `OandaApiV20::RequestError`:
+
+```ruby
+begin
+  do_something
+rescue OandaApiV20::RequestError => e
+  e.original_exception
+end
+```
+
 ## Contributing
 
 1. Fork it

data/lib/oanda_api_v20/accounts.rb

@@ -25,7 +25,7 @@ module OandaApiV20
 
     # GET /v3/accounts/:account_id/changes
     def changes(options = {})
-      options = { 'sinceTransactionID' => last_transaction_id } unless options['sinceTransactionID']
+      options = { 'sinceTransactionID' => nil } unless options['sinceTransactionID']
       Client.send(http_verb, "#{base_uri}/accounts/#{account_id}/changes", headers: headers, query: options)
     end
 

data/lib/oanda_api_v20/api.rb

@@ -8,12 +8,101 @@ module OandaApiV20
     include Transactions
     include Pricing
 
-    attr_accessor :http_verb, :base_uri, :headers, :account_id, :instrument, :last_transaction_id
+    attr_accessor :client, :base_uri, :headers, :account_id, :last_action, :last_arguments
+    attr_writer   :instrument
 
     def initialize(options = {})
       options.each do |key, value|
         self.send("#{key}=", value) if self.respond_to?("#{key}=")
       end
+
+      raise OandaApiV20::ApiError, 'No client object was supplid.' unless client
+      @base_uri ||= client.base_uri
+      @headers  ||= client.headers
+    end
+
+    class << self
+      def api_methods
+        Accounts.instance_methods + Instruments.instance_methods + Orders.instance_methods + Trades.instance_methods + Positions.instance_methods + Transactions.instance_methods + Pricing.instance_methods
+      end
+    end
+
+    self.api_methods.each do |method_name|
+      original_method = instance_method(method_name)
+
+      define_method(method_name) do |*args, &block|
+        # Add the block below before each of the api_methods to set the last_action and last_arguments.
+        # Return the OandaApiV20::Api object to allow for method chaining when any of the api_methods have been called.
+        # Only make an HTTP request to Oanda API when an action method like show, update, cancel, close or create was called.
+        set_last_action_and_arguments(method_name, *args)
+        return self unless http_verb
+
+        original_method.bind(self).call(*args, &block)
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      case name
+      when :show, :create, :update, :cancel, :close
+        set_http_verb(name, last_action)
+
+        if respond_to?(last_action)
+          api_result = {}
+          client.update_last_api_request_at
+          client.govern_api_request_rate
+
+          begin
+            response = Http::Exceptions.wrap_and_check do
+              last_arguments.nil? || last_arguments.empty? ? send(last_action, &block) : send(last_action, *last_arguments, &block)
+            end
+          rescue Http::Exceptions::HttpException => e
+            raise OandaApiV20::RequestError.new(e.message, response: e.response, original_exception: e.original_exception)
+          end
+
+          if response.body && !response.body.empty?
+            api_result.merge!(JSON.parse(response.body))
+          end
+        end
+
+        self.http_verb = nil
+        api_result
+      else
+        super
+      end
+    end
+
+    private
+
+    attr_accessor :http_verb
+
+    def set_last_action_and_arguments(action, *args)
+      self.last_action    = action.to_sym
+      self.last_arguments = args
+    end
+
+    def set_http_verb(action, last_action)
+      case action
+      when :show
+        self.http_verb = :get
+      when :update, :cancel, :close
+        [:configuration].include?(last_action) ? self.http_verb = :patch : self.http_verb = :put
+      when :create
+        self.http_verb = :post
+      else
+        self.http_verb = nil
+      end
+    end
+
+    def parse(buffer, fragment, &block)
+      buffer.split("\n").each do |message|
+        cleaned_message = message.strip
+        next if cleaned_message.empty?
+        yield JSON.parse(cleaned_message)
+      end
+    rescue JSON::ParserError => e
+      raise OandaApiV20::ParseError, "#{e.message} in '#{fragment}'"
+    ensure
+      buffer.clear
     end
   end
 end

data/lib/oanda_api_v20/client.rb

@@ -2,14 +2,18 @@ module OandaApiV20
   class Client
     include HTTParty
 
-    MAX_REQUESTS_PER_SECOND_ALLOWED = 30
-
     BASE_URI = {
-      live:     'https://api-fxtrade.oanda.com/v3',
-      practice: 'https://api-fxpractice.oanda.com/v3'
-    }
+      live: {
+        api:    'https://api-fxtrade.oanda.com/v3',
+        stream: 'https://stream-fxtrade.oanda.com/v3'
+      },
+      practice: {
+        api:    'https://api-fxpractice.oanda.com/v3',
+        stream: 'https://stream-fxpractice.oanda.com/v3'
+      }
+    }.freeze
 
-    attr_accessor :access_token, :proxy_url
+    attr_accessor :access_token, :proxy_url, :max_requests_per_second, :connection_pool_size, :debug
     attr_reader   :base_uri, :headers
 
     def initialize(options = {})
@@ -17,11 +21,15 @@ module OandaApiV20
         self.send("#{key}=", value) if self.respond_to?("#{key}=")
       end
 
-      @debug = options[:debug] || false
-      @last_api_request_at = Array.new(MAX_REQUESTS_PER_SECOND_ALLOWED)
-      @base_uri = options[:practice] == true ? BASE_URI[:practice] : BASE_URI[:live]
+      @mutex                   = Mutex.new
+      @debug                   ||= false
+      @connection_pool_size    ||= 2
+      @max_requests_per_second ||= 100
+      @last_api_request_at     = Array.new(max_requests_per_second)
+      uris                     = options[:practice] == true ? BASE_URI[:practice] : BASE_URI[:live]
+      @base_uri                = options[:stream] == true ? uris[:stream] : uris[:api]
 
-      @headers = {}
+      @headers                             = {}
       @headers['Authorization']            = "Bearer #{access_token}"
       @headers['X-Accept-Datetime-Format'] = 'RFC3339'
       @headers['Content-Type']             = 'application/json'
@@ -35,113 +43,45 @@ module OandaApiV20
         keep_alive:   30,
         idle_timeout: 10,
         warn_timeout: 2,
-        pool_size:    2
+        pool_size:    connection_pool_size
       }
-      persistent_connection_adapter_options.merge!(logger: RubyVM::Logger.new(STDOUT)) if @debug
+
+      persistent_connection_adapter_options.merge!(logger: ::Logger.new(STDOUT), debug_output: ::Logger.new(STDOUT)) if debug
       Client.persistent_connection_adapter(persistent_connection_adapter_options)
     end
 
     def method_missing(name, *args, &block)
       case name
-      when :show, :create, :update, :cancel, :close
-        set_http_verb(name, last_action)
-        api = Api.new(api_attributes)
-
-        if api.respond_to?(last_action)
-          api_result = {}
-          set_last_api_request_at
-          govern_api_request_rate
+      when *Api.api_methods
+        api_attributes = {
+          client:         self,
+          last_action:    name,
+          last_arguments: args
+        }
 
-          begin
-            response = Http::Exceptions.wrap_and_check do
-              last_arguments.nil? || last_arguments.empty? ? api.send(last_action, &block) : api.send(last_action, *last_arguments, &block)
-            end
-          rescue Http::Exceptions::HttpException => e
-            raise OandaApiV20::RequestError, e.message
-          end
+        api_attributes.merge!(account_id: args.first) if name == :account
+        api_attributes.merge!(instrument: args.first) if name == :instrument
 
-          if response.body && !response.body.empty?
-            api_result.merge!(JSON.parse(response.body))
-            set_last_transaction_id(api_result['lastTransactionID']) if api_result['lastTransactionID']
-          end
-        end
-
-        api_result
-      when *api_methods
-        set_last_action_and_arguments(name, args)
-        set_account_id(args.first) if name == :account
-        set_instrument(args.first) if name == :instrument
-        self
+        Api.new(api_attributes)
       else
         super
       end
     end
 
-    private
-
-    attr_accessor :http_verb, :account_id, :instrument, :last_transaction_id, :last_action, :last_arguments, :last_api_request_at
-
-    def api_methods
-      Accounts.instance_methods + Instruments.instance_methods + Orders.instance_methods + Trades.instance_methods + Positions.instance_methods + Transactions.instance_methods + Pricing.instance_methods
-    end
-
     def govern_api_request_rate
       return unless last_api_request_at[0]
-      halt = 1 - (last_api_request_at[MAX_REQUESTS_PER_SECOND_ALLOWED - 1] - last_api_request_at[0])
+      halt = 1 - (last_api_request_at[max_requests_per_second - 1] - last_api_request_at[0])
       sleep halt if halt > 0
     end
 
-    def set_last_api_request_at
-      last_api_request_at.push(Time.now.utc).shift
-    end
-
-    def set_last_action_and_arguments(action, args)
-      set_last_action(action)
-      set_last_arguments(args)
-    end
-
-    def set_last_action(action)
-      self.last_action = action
-    end
-
-    def set_last_arguments(args)
-      self.last_arguments = args.nil? || args.empty? ? nil : args.flatten
-    end
-
-    def set_account_id(id)
-      self.account_id = id
-    end
-
-    def set_instrument(instrument)
-      self.instrument = instrument
-    end
-
-    def set_last_transaction_id(id)
-      self.last_transaction_id = id
-    end
-
-    def set_http_verb(action, last_action)
-      case action
-      when :show
-        self.http_verb = :get
-      when :update, :cancel, :close
-        [:configuration].include?(last_action) ? self.http_verb = :patch : self.http_verb = :put
-      when :create
-        self.http_verb = :post
-      else
-        self.http_verb = nil
+    def update_last_api_request_at
+      @mutex.synchronize do
+        last_api_request_at.push(Time.now.utc).shift
       end
     end
 
-    def api_attributes
-      {
-        http_verb: http_verb,
-        base_uri: base_uri,
-        headers: headers,
-        account_id: account_id,
-        instrument: instrument,
-        last_transaction_id: last_transaction_id
-      }
-    end
+    private
+
+    attr_accessor :last_api_request_at
   end
 end