dtk-client 0.9.1 → 0.10.0

data/lib/client/render.rb

@@ -0,0 +1,113 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Render
+    module Type
+      TABLE  = 'table'
+      SIMPLE = 'simple'
+
+      ALL = [TABLE, SIMPLE]
+      DEFAULT = SIMPLE
+
+      # TODO: DTK-2554: removed below and put in simple, which is yaml
+      # SIMPLE_LIST     = 'simple_list'
+      # PRETTY_PRINT    = 'hash_pretty_print'
+      # AUG_SIMPLE_LIST = 'augmented_simple_list'
+    end
+    
+    Type::ALL.each { |render_type| require_relative("render/view/#{render_type}") }
+
+    extend Auxiliary
+
+    attr_reader :render_type, :semantic_datatype
+    def initialize(render_type, semantic_datatype = nil)
+      @render_type       = render_type
+      @semantic_datatype = semantic_datatype
+    end
+    private :initialize
+
+    # opts can have keys
+    #  :semantic_datatype
+    #  :adapter - way to pass in already created adapter
+    #  :print_error_table - Boolean (default: false)
+    #  :table_definition - pverride to table def associated with semantic_datatype
+    # 
+    # value returned is Boolean indicating whether any additional print needed
+    def self.render(ruby_obj, opts = {})
+      render_type = opts[:render_type]
+      if render_type == Type::TABLE
+        render_opts = {
+          :print_error_table => opts[:print_error_table],
+        }
+        get_adapter(Type::TABLE, opts).render(ruby_obj, render_opts)
+      elsif ruby_obj.kind_of?(Hash)
+        get_adapter(render_type, opts).render(ruby_obj)
+      elsif ruby_obj.kind_of?(Array)
+        get_adapter(render_type, opts).render(ruby_obj)
+      elsif ruby_obj.kind_of?(String)
+        ruby_obj
+      else
+        raise Error.new('ruby_obj has unexpected type')
+      end
+    end
+    
+    private
+
+    def render_text(text)
+      STDOUT << text
+    end
+
+    # opts can have keys
+    #  :adapter - way to pass in already created adapter
+    #  :semantic_datatype
+    def self.get_adapter(render_type, opts = {})
+      return opts[:adapter] if opts[:adapter]
+      
+      raise Error.new('No type is given') unless render_type
+      
+      AdapterCache.get?(render_type, opts[:semantic_datatype]) || AdapterCache.set(create_adapter(render_type, opts))
+    end
+
+    def self.create_adapter(render_type, opts = {})
+      klass = const_get snake_to_camel_case(render_type) 
+      klass.new(render_type, opts)
+    end
+    
+    module AdapterCache
+      STORE_SIMPLE = {}
+      STORE_AUG = {}
+
+      def self.get?(render_type, semantic_datatype = nil)
+        if semantic_datatype
+          (STORE_AUG[render_type]||{})[semantic_datatype]
+        else
+          STORE_SIMPLE[render_type]
+        end
+      end
+      
+      def self.set(adapter)
+        if semantic_datatype = adapter.semantic_datatype
+          (STORE_AUG[adapter.render_type] ||= {})[semantic_datatype] = adapter
+        else
+          STORE_SIMPLE[adapter.render_type] = adapter
+        end
+        adapter
+      end
+    end
+  end
+end

data/lib/client/response/error_handler.rb

@@ -0,0 +1,97 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Response
+    module ErrorHandler
+      def self.raise_if_error(response)
+        Error.raise_if_error(response)
+      end
+
+      def self.check_for_session_expiried(response)
+        error_code = nil
+        if response && response['errors']
+          response['errors'].each do |err|
+            error_code = err['code']||(err['errors'] && err['errors'].first['code'])
+          end
+        end
+        (error_code == 'forbidden')
+      end
+      
+      SpecificErrorCodes = [:unauthorized, :session_timeout, :broken, :forbidden, :timeout, :connection_refused, :resource_not_found, :pg_error]
+      DefaultErrorCode = :error
+      DefaultErrorMsg = 'Internal DTK Client error, please try again'
+      
+      Info = Struct.new(:msg, :code, :backtrace)
+      def self.error_info?(response, opts = {})
+        unless errors = response['errors']
+          return opts[:default_error_if_nil] && error_info_default
+        end
+
+        # special rare case
+        errors = errors.first['errors'] if errors.is_a?(Array) && errors.first['errors']
+
+        error_msg       = ''
+        error_internal  = nil
+        error_backtrace = nil
+        error_code      = nil
+        error_on_server = nil
+
+        #TODO:  below just 'captures' first error
+        errors.each do |err|
+          error_msg       +=  err['message'] unless err['message'].nil?
+          error_msg       +=  err['error']   unless err['error'].nil?
+          error_msg       +=  remove_html_tags(err['original_exception'].to_s) unless err['original_exception'].nil?
+          error_on_server = true unless err['on_client']
+          error_code      = err['code']||(err['errors'] && err['errors'].first['code'])
+          error_internal  ||= (err['internal'] or error_code == 'not_found') #'not_found' code is at Ramaze level; so error_internal not set
+          error_backtrace ||= err['backtrace']
+        end
+        
+        # in case we could not parse error lets log error info
+        if error_msg.empty?
+          Logger.instance.error("Error info could not be extracted from following response: #{response.to_s}")
+        end
+
+        # normalize it for display
+        error_msg = error_msg.empty? ? DefaultErrorMsg : error_msg
+
+        unless error_code and SpecificErrorCodes.include?(error_code)
+          error_code =
+            if error_internal
+              error_on_server ? :server_error : :client_error
+            else
+              DefaultErrorCode
+            end
+        end
+
+        error_code = error_code.to_sym
+        Info.new(error_msg, error_code, error_backtrace)
+      end
+
+      private
+
+      def self.remove_html_tags(string_with_tags)
+        string_with_tags.gsub(/<\/?[^>]+>/, '')
+      end
+
+      def self.error_info_default
+        Info.new(DefaultErrorMsg, DefaultErrorCode, nil)
+      end
+    end
+  end
+end

data/lib/client/response/render_helper.rb

@@ -0,0 +1,78 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This is wrapper for holding rest response information as well as
+# passing selection of ViewProcessor from Thor selection to render view
+# selection
+module DTK::Client
+  class Response
+    module RenderHelperMixin
+      def render_attributes_init!
+        @semantic_datatype = nil
+        @skip_render       = false
+        @render_type       = Render::Type::DEFAULT
+      end
+      private :render_attributes_init!
+
+      def render_data(print_error_table = false)
+        return if @skip_render
+
+        @print_error_table ||= print_error_table
+
+        render_opts = {
+          :render_type       => @render_type,
+          :semantic_datatype => @semantic_datatype,
+          :print_error_table => @print_error_table
+        }
+        Render.render(data, render_opts)
+      end
+          
+      def set_render_as_table!(semantic_datatype = nil)
+        return self unless ok?
+
+        unless semantic_datatype ||= semantic_datatype_in_payload
+          error_hash = {
+            'message'   => 'Server did not return table datatype',
+            'on_client' => false
+          }
+          return ErrorResponse::Internal.new(error_hash)
+        end
+        @semantic_datatype = normalize_semantic_datatype(semantic_datatype)
+        @render_type = Render::Type::TABLE
+        self
+      end
+
+      def skip_render(skip)
+        @skip_render = skip
+      end
+
+      private
+
+      def semantic_datatype_in_payload
+        self['datatype'] && self['datatype'].to_sym
+      end
+
+      def hash_part
+        keys.inject(Hash.new){|h,k|h.merge(k => self[k])}
+      end
+
+      def normalize_semantic_datatype(semantic_datatype)
+        semantic_datatype && semantic_datatype.to_sym
+      end
+    end
+  end
+end

data/lib/client/response/subclasses.rb

@@ -0,0 +1,62 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This is wrapper for holding rest response information as well as
+# passing selection of ViewProcessor from Thor selection to render view
+# selection
+module DTK::Client
+  class Response
+    class Ok < self
+      def initialize(data = {})
+        super('data'=> data, 'status' => 'ok')
+      end
+    end
+    
+    class NotOk < self
+      def initialize(data = {})
+        super('data'=> data, 'status' => 'notok')
+      end
+    end
+    
+    class NoOp < self
+      def render_data
+      end
+    end
+    
+    class ErrorResponse < self
+      include ::DTK::Common::Response::ErrorMixin
+      def initialize(hash = {})
+        super('errors' => [hash])
+      end
+      private :initialize
+      
+      class Usage < self
+        def initialize(hash_or_string = {})
+          hash = (hash_or_string.kind_of?(String) ? {'message' => hash_or_string} : hash_or_string)
+          super({'code' => 'error'}.merge(hash))
+        end
+      end
+      
+      class Internal < self
+        def initialize(hash = {})
+          super({'code' => 'error'}.merge(hash).merge('internal' => true))
+        end
+      end
+    end
+  end
+end
+

data/lib/client/response.rb

@@ -0,0 +1,83 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This is wrapper for holding rest response information as well as
+# passing selection of ViewProcessor from Thor selection to render view
+# selection
+require 'dtk_common_core' 
+
+module DTK::Client
+  class Response < ::DTK::Common::Response
+    require_relative('response/error_handler')
+    require_relative('response/render_helper')
+    require_relative('response/subclasses')
+
+    include RenderHelperMixin
+
+    def initialize(hash = {})
+      super(hash)
+      @print_error_table = false #we use it if we want to print 'error legend' for given tables 
+      render_attributes_init!
+    end
+
+    # opts can be
+    #  :default_error_if_nil - Boolean
+    def error_info?(opts = {})
+      ErrorHandler.error_info?(self, opts)
+    end
+    
+    # This method is used so that client side actions can be wrapped like calls to server
+    def self.wrap_as_response(data = {}, &block)
+      results = (block ? yield : data)
+      if results.nil?
+        NoOp.new
+      elsif results.kind_of?(Response)
+        results
+      else
+        Ok.new(results)
+      end
+    end
+
+    def index_data(*indexes)
+      index_common(*indexes) { |_indexes| nil }
+    end
+    
+    def required(*indexes)
+      index_common(*indexes) do |indexes| 
+        raise Error, "Missing response field 'response[:#{indexes.join('][:')}]'" 
+      end
+    end
+
+    private
+
+    def index_common(*indexes, &block_when_no_data)
+      if indexes.empty?
+        raise Error, 'indexes should not be empty'
+      else
+        val = data
+        indexes.each do |key|
+          unless val.kind_of?(::Hash) and val.has_key?(key.to_s)
+            return block_when_no_data.call(indexes)
+          end
+          val = val[key.to_s]
+        end
+        val
+      end
+    end
+  end
+end
+

data/lib/client/session.rb

@@ -0,0 +1,62 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'singleton'
+
+module DTK::Client
+  ##
+  # Session Singleton we will use to hold connection instance, just a singleton wrapper.
+  # During shell input it will be needed only once, so singleton was obvious solution.
+  #
+  class Session
+    include Singleton
+
+    attr_accessor :conn
+    
+    def initialize
+      @conn = Conn.new
+    end
+    
+    def self.get_connection
+      instance.conn
+    end
+    
+    def self.connection_username
+      instance.conn.get_username
+    end
+    
+    def self.re_initialize
+      instance.conn = nil
+      instance.conn = Conn.new
+      instance.conn.cookies
+    end
+    
+    def self.logout
+      # from this point @conn is not valid, since there are no cookies set
+      instance.conn.logout
+    end
+    
+    def self.rest_post(route, post_body = {})
+      instance.conn.post(route, post_body)
+    end
+
+    def self.rest_get(route, opts = {})
+      instance.conn.get(route, opts)
+    end
+
+  end
+end

data/lib/client/util/auxiliary.rb

@@ -0,0 +1,34 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'yaml'
+
+module DTK::Client
+  module Auxiliary
+    def snake_to_camel_case(snake_form)
+      snake_form.to_s.gsub('-','_').to_s.split('_').map{|t|t.capitalize}.join('')
+    end
+    
+    def snake_form(command_class, seperator='_')
+      command_class.to_s.gsub(/^.*::/, '').gsub(/Command$/,'').scan(/[A-Z][a-z]+/).map{|w|w.downcase}.join(seperator)
+    end
+
+    def hash_to_yaml(hash_content)
+      YAML.dump(hash_content)
+    end
+  end
+end

data/lib/client/util/console.rb

@@ -0,0 +1,81 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'highline/import'
+
+module DTK::Client
+  module Console
+    # Display confirmation prompt and repeat message until expected answer is given
+    #
+    # opts can have keys
+    #   :disable_ctrl_c - Boolean (default: true)
+    #   :add_options - Boolean (default: false)
+    def self.prompt_yes_no(message, opts = {})
+      # used to disable skip with ctrl+c
+      prompt_context(opts) do
+        message += ' (yes|no)' if opts[:add_options]
+        HighLine.agree(message)
+      end
+    end
+
+    def self.wait_animation(message, time_seconds)
+      print message
+      print " [     ]"
+      STDOUT.flush
+      time_seconds.downto(1) do
+        1.upto(4) do |i|
+          next_output = "\b\b\b\b\b\b\b"
+          case
+           when i % 4 == 0
+            next_output  += "[ =   ]"
+           when i % 3 == 0
+             next_output += "[  =  ]"
+           when i % 2 == 0
+            next_output  += "[   = ]"
+           else
+            next_output  += "[  =  ]"
+          end
+
+          print next_output
+          STDOUT.flush
+          sleep(0.25)
+        end
+      end
+      # remove loading animation
+      print "\b\b\b\b\b\b\bRefreshing..."
+      STDOUT.flush
+      puts
+    end
+
+    private
+
+    # opts can have keys
+    #   :disable_ctrl_c - Boolean (default: true)
+    def self.prompt_context(opts = {}, &body)
+      "#{opts[:disable_ctrl_c]}" == 'false' ? body.call : disable_ctrl_c(&body)
+    end
+
+    def self.disable_ctrl_c(&body)
+      trap('INT', 'SIG_IGN')
+      begin
+        body.call
+      ensure
+        trap('INT', false)
+      end
+    end
+  end
+end

data/lib/client/util/disk_cacher.rb

@@ -0,0 +1,66 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  #
+  # Class dedicated for caching data on local system as well as for cookie management
+  #
+  class DiskCacher
+    # file name to hold cookies
+    COOKIE_HOLDER_NAME = 'tempdtkstore'
+    FILE_DELIMITER = '--'
+    
+    def initialize(cache_dir = OsUtil.temp_dir)
+      @cache_dir = cache_dir
+      @current_user = Configurator.client_username
+    end
+    
+    def fetch(file_name, max_age = 0, use_mock_up = true)
+      file = Digest::MD5.hexdigest(file_name)
+      # current user is important so that there are no clashes in writting to temp file
+      # between multiple users on same machine
+      file_path = File.join(@cache_dir, "#{@current_user}#{FILE_DELIMITER}#{file}")
+      
+      # we check if the file -- a MD5 hexdigest of the URL -- exists
+      #  in the dir. If it does and the data is fresh, we just read
+      #  data from the file and return
+      if File.exists? file_path
+        return File.new(file_path).read if ((Time.now - File.mtime(file_path)) < max_age)
+      end
+      
+      # if the file does not exist (or if the data is not fresh), we
+      #  make an get request and save it to a file
+      response_string = ''
+      response = Session.rest_get("metadata/get/#{file_name}")
+      File.open(file_path, 'w') { |f| f << response_string = response.data } if response.ok? 
+      response_string
+    end
+    
+    def save_cookie(cookie_content)
+      file_path = File.join(@cache_dir, COOKIE_HOLDER_NAME)
+      File.open(file_path, 'w') do |file|
+        Marshal.dump(cookie_content, file)
+      end
+    end
+    
+    def load_cookie
+      file_path = File.join(@cache_dir, COOKIE_HOLDER_NAME)
+      cookie_content = File.exists?(file_path) ? File.open(file_path) {|f| Marshal.load(f)} : nil
+      cookie_content
+    end
+  end
+end