domoscio_viz 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 050c44f613da493c3ca25fd68c8ba142362bf42f461cb20e39934a88688bc53f
-  data.tar.gz: 83f2f4df4edcb932d70fd9a52b993369a3e758c2ec4f9d1d43c0da9ee458bcbd
+  metadata.gz: a27998a16cab08757bb639a589e3b6fac992c8edc215ddd1bef66244be05c983
+  data.tar.gz: 5574e4cde4e47c488626f6598fe1b2299221bb753416b8c388f8ff3cf190581d
 SHA512:
-  metadata.gz: 7ad6e1ebc52711ef09bcaf1fbe20da7ae480750829b967702094963f63db1c7679206db7333533d02157235c5056bd8876a5cff76618bac08e584209893d5912
-  data.tar.gz: e9d0ad596fe0f9c4f8e5411d7a41e962ece08f5c19a7c6ee9b568f24008b76a4d1484914a745aa6d39fad62c4d3e270367c5b62a5da15d64e1f3d042f7c48d14
+  metadata.gz: 5f72c732c781f5cc4ab2fd5181547c7e65c07af79b12c98a2554885af42802d08abef81eb86329a4dd374f682d74929c6c6430e56e52515a57cb59931d9c8ce2
+  data.tar.gz: 5b3e486ef10f27616094adf973124afcb86c3b202c742500c73e635ce8040d11430708bdd3aee31e81ad6d182dcc3632019181778b861e75d9a9de3f4be40678

data/Rakefile

@@ -14,9 +14,6 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-
-
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
@@ -28,5 +25,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
 task default: :test

data/lib/domoscio_viz/authorization_token.rb

@@ -1,59 +1,53 @@
 module DomoscioViz
   module AuthorizationToken
+    # Token Manager
     class Manager
-
       class << self
         def storage
-          @@storage ||= FileStorage.new
-        end
-
-        def storage= (storage)
-          @@storage = storage
+          @storage ||= DomoscioViz.configuration.file_storage ? FileStorage.new : ManualSetting.new
         end
 
-        def get_token
-          token = storage.get
-          token = DomoscioViz.configuration.client_passphrase if token.nil?
-          token
+        def token
+          storage.get
         end
       end
     end
 
-    class StaticStorage
+    # Manages tokens with configuration
+    class ManualSetting
       def get
-        @@token ||= nil
+        {
+          access_token: DomoscioViz.configuration.access_token,
+          refresh_token: DomoscioViz.configuration.refresh_token
+        }
       end
 
       def store(token)
-        @@token = token
+        DomoscioViz.configuration.access_token = token[:access_token]
+        DomoscioViz.configuration.refresh_token = token[:refresh_token]
       end
     end
 
+    # Manages tokens with local File
     class FileStorage
       require 'yaml'
-      @temp_dir
 
-      def initialize(temp_dir = nil)
-        @temp_dir = temp_dir || DomoscioViz.configuration.temp_dir
-        if !@temp_dir
-          raise "Path to temporary folder is not defined"
-        end
+      def initialize
+        raise 'Path to temporary folder is not defined' unless DomoscioViz.configuration.temp_dir
       end
 
       def get
-        begin
-          f = File.open(file_path, File::RDONLY)
-          f.flock(File::LOCK_SH)
-          txt = f.read
-          f.close
-          YAML.load(txt) || nil
-        rescue Errno::ENOENT
-          nil
-        end
+        f = File.open(file_path, File::RDONLY)
+        f.flock(File::LOCK_SH)
+        txt = f.read
+        f.close
+        YAML.safe_load(txt) || nil
+      rescue Errno::ENOENT
+        nil
       end
 
       def store(token)
-        File.open(file_path, File::RDWR|File::CREAT, 0644) do |f|
+        File.open(file_path, File::RDWR|File::CREAT, 0o644) do |f|
           f.flock(File::LOCK_EX)
           f.truncate(0)
           f.rewind
@@ -62,8 +56,8 @@ module DomoscioViz
       end
 
       def file_path
-        File.join(@temp_dir, "DomoscioViz.AuthorizationToken.FileStore.tmp")
+        File.join(DomoscioViz.configuration.temp_dir, 'DomoscioViz.AuthorizationToken.FileStore.tmp')
       end
     end
   end
-end
+end

data/lib/domoscio_viz/chart/chart.rb

@@ -1,6 +1,6 @@
 module DomoscioViz
-  # A Recommandation.
+  # Regroup all charts
   class Chart < Resource
     include DomoscioViz::HTTPCalls::GetUrl
   end
-end
+end

data/lib/domoscio_viz/errors.rb

@@ -1,26 +1,41 @@
 module DomoscioViz
   # Generic error superclass for MangoPay specific errors.
-  # Currently never instantiated directly.
-  # Currently only single subclass used.
   class Error < StandardError
   end
-  # ErrorMessage from VizEngine 
+
+  # Error Message from VizEngine
   class ResponseError < Error
     attr_reader :request_url, :code, :details, :body, :request_params
-    def initialize(request_url, code, details, body, request_params)
-      @request_url, @code, @details, @body, @request_params = request_url, code, details, body, request_params
+
+    def initialize(request_url, code, details = {}, body = nil, request_params = {})
+      @request_url = request_url
+      @code = code
+      @details = details
+      @body = body
+      @request_params = request_params
       super(message) if message
     end
-    def message; @details.dig(:error, :message) || @details; end
+
+    def message
+      @details.is_a?(Hash) && @details[:error].is_a?(Hash) ? @details.dig(:error, :message) : @details
+    end
   end
 
-  # ProcessingError from Domoscio_viz
+  # ProcessingError from DomoscioViz
   class ProcessingError < Error
     attr_reader :request_url, :code, :details, :body, :request_params
-    def initialize(request_url, code, details, body, request_params)
-      @request_url, @code, @details, @body, @request_params = request_url, code, details, body, request_params
+
+    def initialize(request_url, code, details = {}, body = nil, request_params = {})
+      @request_url = request_url
+      @code = code
+      @details = details
+      @body = body
+      @request_params = request_params
       super(message) if message
     end
-    def message; @details.message; end
+
+    def message
+      @details.message
+    end
   end
-end
+end

data/lib/domoscio_viz/http_calls.rb

@@ -2,18 +2,14 @@ module DomoscioViz
   module HTTPCalls
     module GetUrl
       module ClassMethods
-        # In order to catch current SocketsTimeoutError that seem to appear when the VizEngine stays Idle for too long
-        # Perform the request a second time if it fails the fisrt time
         def get_url(util_name = nil, params = {})
-          response = DomoscioViz.request(:post, url(util_name), params)
-          response = DomoscioViz.request(:post, url(util_name), params) unless response && response.is_a?(Hash) && response['url'] && response['success'] == true
-          response
+          DomoscioViz.request(:post, url(util_name), params)
         end
       end
 
       def self.included(base)
         base.extend(ClassMethods)
-      end      
+      end
     end
   end
-end
+end

data/lib/domoscio_viz/json.rb

@@ -20,4 +20,4 @@ module DomoscioViz
       end
     end
   end
-end
+end

data/lib/domoscio_viz/resource.rb

@@ -2,23 +2,11 @@ module DomoscioViz
   # @abstract
   class Resource
     class << self
-      def class_name
-        name.split('::')[-1]
-      end
+      def url(util_name = nil, on_self = nil)
+        raise NotImplementedError, 'Resource is an abstract class. Do not use it directly.' if self == Resource
 
-      def url(util_name = nil, on_self = nil )
-        if self == Resource
-          raise NotImplementedError.new('Resource is an abstract class. Do not use it directly.')
-        end
-        
-        build_url = ""
-        if !on_self
-          if util_name
-            build_url << "/#{util_name}"
-          end
-        end
-        return build_url  
+        util_name && !on_self ? "/#{util_name}" : ''
       end
     end
   end
-end
+end

data/lib/domoscio_viz/version.rb

@@ -1,3 +1,3 @@
 module DomoscioViz
-  VERSION = "0.2.3"
-end
+  VERSION = '0.3.1'.freeze
+end

data/lib/domoscio_viz.rb

@@ -1,44 +1,23 @@
-
 require 'net/https'
 require 'cgi/util'
 require 'multi_json'
-# helpers
+
 require 'domoscio_viz/version'
 require 'domoscio_viz/json'
 require 'domoscio_viz/errors'
 require 'domoscio_viz/authorization_token'
-# generators
-require 'domoscio_viz/generators/install_generator'
-# resources
 require 'domoscio_viz/http_calls'
 require 'domoscio_viz/resource'
 require 'domoscio_viz/chart/chart'
 
 module DomoscioViz
-
   class Configuration
-    attr_accessor :preproduction, :test, :root_url,
-    :client_id, :client_passphrase,
-    :temp_dir
-
-    def preproduction
-      @preproduction || false
-    end
-       
-    def test
-      @test || false
-    end
+    attr_accessor :client_id, :client_passphrase, :temp_dir,
+                  :root_url, :file_storage, :access_token, :refresh_token
 
-    def root_url
-      if @preproduction == true
-        if @test == true
-          @root_url || "https://domoscio-viz-engine-preprod.azurewebsites.net"
-        else
-          @root_url || "https://domoscio-viz-engine-v2.azurewebsites.net"
-        end
-      else
-        @root_url || "http://localhost:3002"
-      end
+    def initialize
+      @root_url = ''
+      @file_storage ||= true
     end
   end
 
@@ -56,85 +35,135 @@ module DomoscioViz
   end
 
   #
-  def self.request(method, url, params={}, filters={}, headers = request_headers, before_request_proc = nil)
-    return false if @disabled
+  # - +method+: HTTP method; lowercase symbol, e.g. :get, :post etc.
+  # - +url+: the part after Configuration#root_url
+  # - +params+: hash; entity data for creation, update etc.; will dump it by JSON and assign to Net::HTTPRequest#body
+  #
+  # Performs HTTP requests to Adaptive Engine
+  # On token issues, will try once to get a new token then will output a DomoscioViz::ReponseError with details
+  #
+  # Raises DomoscioViz::ResponseError on Adaptive Error Status
+  # Raises DomoscioViz::ProcessingError on Internal Error
+  #
+  def self.request(method, url, params={})
+    store_tokens, headers = request_headers
     uri = api_uri(url)
-    uri.query = URI.encode_www_form(filters) unless filters.empty?
-    res = DomoscioViz.send_request(uri, method, params, headers, before_request_proc)
-    return res if res.kind_of? DomoscioViz::ProcessingError
-     # decode json data
-     begin
-      data = DomoscioViz::JSON.load(res.body.nil? ? '' : res.body)
-      raise ResponseError.new(uri, res.code.to_i, data, res.body, params) unless res.kind_of? Net::HTTPSuccess
-      unless (res.kind_of? Net::HTTPClientError) || (res.kind_of? Net::HTTPServerError)
-        DomoscioViz::AuthorizationToken::Manager.storage.store({access_token: res['Accesstoken'], refresh_token: res['Refreshtoken']})
+    response = DomoscioViz.send_request(uri, method, params, headers)
+    return response if response.is_a? DomoscioViz::ProcessingError
+
+    begin
+      raise_http_failure(uri, response, params)
+      data = DomoscioViz::JSON.load(response.body.nil? ? '' : response.body)
+      if store_tokens
+        DomoscioViz::AuthorizationToken::Manager.storage.store({
+                                                                 access_token: response['Accesstoken'],
+                                                                 refresh_token: response['Refreshtoken']
+                                                               })
       end
-    rescue MultiJson::LoadError => exception
-      return ProcessingError.new(uri, 500, exception, res.body, params)
-    rescue ResponseError => exception
-      return exception
+    rescue MultiJson::LoadError => e
+      data = ProcessingError.new(uri, 500, e, response.body, params)
+    rescue ResponseError => e
+      data = e
     end
     data
   end
 
-  def self.send_request(uri, method, params, headers, before_request_proc)
-    begin
-      res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
-        req = Net::HTTP::const_get(method.capitalize).new(uri.request_uri, headers)
-        req.body = DomoscioRails::JSON.dump(params)
-        before_request_proc.call(req) if before_request_proc
-        http.request req
-      end
-    rescue Timeout::Error, Errno::EINVAL, HTTP::ConnectionError, Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => exception
-      ProcessingError.new(uri, 500, exception, res.body, params)
+  # This function catches usual Http errors during calls
+  #
+  def self.send_request(uri, method, params, headers)
+    response = perform_call(uri, method, params, headers)
+    response = retry_call_and_store_tokens(uri, method, params) if %w[401 403].include? response.code
+    response
+  rescue Timeout::Error, Errno::EINVAL, HTTP::ConnectionError, Errno::ECONNREFUSED,
+         Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+    ProcessingError.new(uri, 500, e, response, params)
+  end
+
+  # This helper will check the response status and build the correcponding DomoscioRails::ResponseError
+  #
+  def self.raise_http_failure(uri, response, params)
+    return if response.is_a? Net::HTTPSuccess
+
+    raise ResponseError.new(
+      uri,
+      response.code.to_i,
+      DomoscioViz::JSON.load((response.body.nil? ? '' : response.body), symbolize_keys: true),
+      response.body, params
+    )
+  end
+
+  # Actual HTTP call is performed here
+  #
+  def self.perform_call(uri, method, params, headers)
+    Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      req = Net::HTTP::const_get(method.capitalize).new(uri.request_uri, headers)
+      req.body = DomoscioRails::JSON.dump(params)
+      http.request req
     end
   end
 
-  private
+  # This method is called when AdaptiveEngine returns tokens errors
+  # Action on those errors is to retry and request new tokens, those new token are then stored
+  def self.retry_call_and_store_tokens(uri, method, params)
+    headers = request_new_tokens
+    response = perform_call(uri, method, params, headers)
+    DomoscioViz::AuthorizationToken::Manager.storage.store({
+                                                             access_token: response['Accesstoken'],
+                                                             refresh_token: response['Refreshtoken']
+                                                           })
+    response
+  end
 
   def self.user_agent
-    @uname ||= get_uname
+    @uname ||= uname
     {
       bindings_version: DomoscioViz::VERSION,
       lang: 'ruby',
       lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
       platform: RUBY_PLATFORM,
       uname: @uname
-    }
+    }.to_s
   end
 
-  def self.get_uname
-    `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+  def self.uname
+    `uname -a 2>/dev/null` if RUBY_PLATFORM =~ /linux|darwin/i
   rescue Errno::ENOMEM
     'uname lookup failed'
   end
 
+  # Process the token loading and analyze
+  # will return the processed headers and a token store flag
+  #
   def self.request_headers
     auth_token = DomoscioViz::AuthorizationToken::Manager.get_token
-    if !auth_token.is_a? String
-      headers = {
-        'user_agent' => "#{DomoscioViz.user_agent}",
-        'ClientId' => "#{DomoscioViz.configuration.client_id}",
-        'AccessToken' => "#{auth_token[:access_token]}",
-        'RefreshToken' => "#{auth_token[:refresh_token]}",
-        'Content-Type' => 'application/json'
-      }
+    if auth_token && auth_token[:access_token] && auth_token[:refresh_token]
+      [false, send_current_tokens(auth_token)]
     else
-      headers = {
-        'user_agent' => "#{DomoscioViz.user_agent}",
-        'ClientId' => "#{DomoscioViz.configuration.client_id}",
-        'Authorization' => "Token token=#{DomoscioViz.configuration.client_passphrase}",
-        'Content-Type' => 'application/json'
-      }
+      [true, request_new_tokens]
     end
-    headers
+  rescue SyntaxError, StandardError
+    [true, request_new_tokens]
+  end
+
+  # If stored token successfully loaded we build the header with them
+  #
+  def self.send_current_tokens(auth_token)
+    {
+      'user_agent' => DomoscioViz.user_agent,
+      'ClientId' => DomoscioViz.configuration.client_id,
+      'AccessToken' => auth_token[:access_token],
+      'RefreshToken' => auth_token[:refresh_token],
+      'Content-Type' => 'application/json'
+    }
   end
 
-  DomoscioViz.configure do |c|
-      c.preproduction = false
-      c.client_id = nil
-      c.client_passphrase = nil
-      c.temp_dir = File.expand_path('../tmp', __FILE__)
-      FileUtils.mkdir_p(c.temp_dir) unless File.directory?(c.temp_dir)
+  # If we cant find tokens of they are corrupted / expired, then we set headers to request new ones
+  def self.request_new_tokens
+    {
+      'user_agent' => DomoscioViz.user_agent,
+      'ClientId' => DomoscioViz.configuration.client_id,
+      'Authorization' => "Token token=#{DomoscioViz.configuration.client_passphrase}",
+      'Content-Type' => 'application/json'
+    }
   end
-end
+end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: domoscio_viz
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - Benoit Praly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2022-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: 1.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: 1.15.0
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 description: Ruby client to interact with Domoscio Viz Engine.
 email:
 - benoit.praly@domoscio.com
@@ -38,8 +52,6 @@ files:
 - lib/domoscio_viz/authorization_token.rb
 - lib/domoscio_viz/chart/chart.rb
 - lib/domoscio_viz/errors.rb
-- lib/domoscio_viz/generators/install_generator.rb
-- lib/domoscio_viz/generators/templates/install.rb
 - lib/domoscio_viz/http_calls.rb
 - lib/domoscio_viz/json.rb
 - lib/domoscio_viz/resource.rb
@@ -56,14 +68,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Summary of DomoscioViz.

data/lib/domoscio_viz/generators/install_generator.rb

@@ -1,10 +0,0 @@
-require 'rails/generators'
-module DomoscioViz
-  class InstallGenerator < ::Rails::Generators::Base
-    source_root File.expand_path('../templates', __FILE__)
-    desc "Generate config file for DomoscioViz configuration"
-    def install
-        copy_file "install.rb", "config/initializers/domoscio_viz.rb"
-    end
-  end
-end

data/lib/domoscio_viz/generators/templates/install.rb

@@ -1,11 +0,0 @@
-DomoscioViz.configure do |c|
-    if Rails.env == "production"
-        c.preproduction = true
-    else
-        c.preproduction = false
-    end
-    c.client_id = ENV['DOMOSCIO_ID']
-    c.client_passphrase = ENV['DOMOSCIO_PASSWORD']
-    c.temp_dir = File.expand_path('../tmp', __FILE__)
-    FileUtils.mkdir_p(c.temp_dir) unless File.directory?(c.temp_dir)
-end