dtk-client 0.7.4.1 → 0.7.5

data/lib/domain/response.rb

@@ -7,6 +7,9 @@ module DTK
   module Client
     #TODO: should make higher level class be above whether it is 'rest'
     class Response < Common::Response
+      require File.expand_path('response/error_handler',File.dirname(__FILE__))
+      include ErrorHandlerMixin
+
       # :render_view        => symbol specifing type of data to be rendered e.g. :assembly
       # :skip_render        => flag that specifies that render is not needed (default: false)
       # :print_error_table  => we use it if we want to print 'error legend' for given tables (default: false)
@@ -230,6 +233,12 @@ module DTK
         end
       end
 
+      class NotOk < self
+        def initialize(data={})
+          super(nil,{"data"=> data, "status" => "notok"})
+        end
+      end
+
       class Error < self
         include Common::Response::ErrorMixin
         def initialize(hash={})

data/lib/domain/response/error_handler.rb

@@ -0,0 +1,61 @@
+module DTK; module Client
+  class Response
+    module ErrorHandlerMixin
+      # opts can be
+      #  :default_error_if_nil - Boolean
+      def error_info?(opts={})
+        ErrorHandler.error_info?(self,opts)
+      end
+    end
+
+    module ErrorHandler
+      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
+
+        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_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
+
+        # 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
+
+      def self.error_info_default()
+        Info.new(DefaultErrorMsg,DefaultErrorCode,nil)
+      end
+
+    end
+  end
+end; end
+

data/lib/dtk-client/version.rb

@@ -1,3 +1,3 @@
 module DtkClient
-  VERSION="0.7.4.1"
+  VERSION="0.7.5"
 end

data/lib/dtk_client.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../client', __FILE__)
+require File.expand_path('../configurator', __FILE__)
+require File.expand_path('../parser/adapters/thor',    __FILE__)
+require File.expand_path('../shell/context', __FILE__)
+require File.expand_path('../shell/domain/context_entity', __FILE__)
+require File.expand_path('../shell/domain/active_context', __FILE__)
+require File.expand_path('../shell/domain/context_params', __FILE__)
+require File.expand_path('../shell/domain/override_tasks', __FILE__)
+require File.expand_path('../shell/domain/shadow_entity', __FILE__)
+require File.expand_path('../commands/thor/account', __FILE__)
+require File.expand_path('../shell/parse_monkey_patch', __FILE__)
+require File.expand_path('../shell/help_monkey_patch', __FILE__)
+require File.expand_path('../execute/cli_pure/cli_rerouter', __FILE__)
+require File.expand_path('../context_router', __FILE__)

data/lib/dtk_error.rb

@@ -0,0 +1,91 @@
+module DTK
+  module Client
+    class DtkError < Error
+      def initialize(msg,opts={})
+        super(msg)
+        @backtrace = opts[:backtrace]
+      end
+      attr_reader :backtrace
+
+      def self.raise_error(response)
+        raise_if_error?(response,:default_error_if_nil => true)
+      end
+      def self.raise_if_error?(response,opts={})
+        # check for errors in response
+        unless error = response.error_info?(opts)
+          return
+        end
+        
+        # if error_internal.first == true
+        case error.code
+          when :unauthorized
+            raise self, "[UNAUTHORIZED] Your session has been suspended, please log in again."
+          when :session_timeout
+            raise self, "[SESSION TIMEOUT] Your session has been suspended, please log in again."
+          when :broken
+            raise self, "[BROKEN] Unable to connect to the DTK server at host: #{Config[:server_host]}"
+          when :forbidden
+            raise DTK::Client::DtkLoginRequiredError, "[FORBIDDEN] Access not granted, please log in again."
+          when :timeout
+            raise self, "[TIMEOUT ERROR] Server is taking too long to respond."
+          when :connection_refused
+            raise self, "[CONNECTION REFUSED] Connection refused by server."
+          when :resource_not_found
+            raise self, "[RESOURCE NOT FOUND] #{error.msg}"
+          when :pg_error
+            raise self, "[PG_ERROR] #{error.msg}"
+          when :server_error
+            raise Server.new(error.msg,:backtrace => error.backtrace)
+          when :client_error
+            raise Client.new(error.msg,:backtrace => error.backtrace)
+          else
+          # if usage error occurred, display message to console and display that same message to log
+            raise Usage.new(error.msg)
+        end
+      end
+
+
+      class Usage < self
+        def initialize(error_msg,opts={})
+          msg_to_pass_to_super = "[ERROR] #{error_msg}"
+          super(msg_to_pass_to_super,opts)
+        end
+      end
+
+      class InternalError < self
+        def initialize(error_msg,opts={})
+          msg_to_pass_to_super = "[#{label(opts[:where])}] #{error_msg}"
+          super(msg_to_pass_to_super,opts)
+        end
+        def self.label(where=nil)
+          prefix = (where ? "#{where.to_s.upcase} " : '')
+          "#{prefix}#{InternalErrorLabel}"
+        end
+        InternalErrorLabel = 'INTERNAL ERROR'
+
+       private
+        def label(where=nil)
+          self.class.label(where)
+        end
+      end
+
+      class Client < InternalError
+        def initialize(error_msg,opts={})
+          super(error_msg,opts.merge(:where => :client))
+        end
+        def self.label(*args)
+          super(:client)
+        end
+      end
+      class Server < InternalError
+        def initialize(error_msg,opts={})
+          super(error_msg,opts.merge(:where => :server))
+        end
+        def self.label(*args)
+          super(:server)
+          end
+      end
+
+    end
+  end
+end

data/lib/error.rb

@@ -8,6 +8,9 @@ module DTK
     class Error < NameError
     end
 
+   # DtkError is child of Error; so order matters
+    require File.expand_path('dtk_error', File.dirname(__FILE__))
+
     class DSLParsing < Error
       def initialize(base_json_error,file_path=nil)
         super(err_msg(base_json_error,file_path))
@@ -48,15 +51,6 @@ module DTK
     class DtkImplementationError < Error
     end
 
-    # we use this to log application errors
-    class DtkError < Error
-      def initialize(msg,opts={})
-        super(msg)
-        @backtrace = opts[:backtrace]
-      end
-      attr_reader :backtrace
-    end
-
     class DtkLoginRequiredError < Error
     end
 

data/lib/execute/cli_pure/cli_rerouter.rb

@@ -0,0 +1,82 @@
+module DTK
+  class CLIRerouter
+
+    ROUTER_DATA = {
+      :service_module => [
+          { :regex => /service-module (?<service_module_id>[\w:\-]+) (?<method_name>stage) (?<assembly_id>[\w:\-]+) (?<instance_name>[\w:\-\.\:]+)/, :entity => 'assembly' },
+          { :regex => /service-module (?<service_module_id>[\w:\-]+) (?<method_name>deploy) (?<assembly_id>[\w:\-]+) (?<instance_name>[\w:\-\.\:]+)/ }
+        ],
+      :service        => [
+          { :regex => /service (?<service_id>[\w:\-]+) (?<method_name>set-attribute) (?<name>[\w:\-\.\:]+) (?<value>[\w:\-\.\:]+)/ },
+          { :regex => /service (?<service_id>[\w:\-]+) (?<method_name>converge)/ },
+          { :regex => /service (?<method_name>delete-and-destroy) (?<instance_name>[\w:\-]+)/ }
+        ]
+    }
+
+    def initialize(entity_name, args)
+      @cli_string  = CLIRerouter.formulate_command_string(entity_name, args)
+      @entity_name = CLIRerouter.norm(entity_name)
+
+      ROUTER_DATA[@entity_name].each do |defintion|
+        if match = @cli_string.match(defintion[:regex])
+          @method_name = CLIRerouter.norm(match[:method_name])
+
+          # sometimes we need to override entity
+          @entity_name = defintion[:entity] if defintion[:entity]
+
+          # we need to filter out IDs
+          @entity_ids  = match.names.collect { |k| k.to_s.end_with?('_id') ? { k => match[k] } : nil }.compact
+
+          if @entity_ids.empty?
+            # match 1 is method name, there is no id
+            @args = match[2, match.size]
+          else
+            # match 1, 2 are id and method name rest are args
+            @args = match[@entity_ids.size + 2, match.size]
+          end
+
+          break
+        end
+      end
+
+      @conn = ::DTK::Client::Session.get_connection()
+      exit if validate_connection(@conn)
+    end
+
+    def run
+      new_context_params = DTK::Shell::ContextParams.new
+
+      @entity_ids.each do |value_hash|
+        key    = value_hash.keys.first
+        value  = value_hash.values.first
+        entity_name_of_param = key.gsub('_id', '')
+        new_context_params.add_context_name_to_params(entity_name_of_param, entity_name_of_param, value)
+      end
+
+      new_context_params.method_arguments = @args
+      new_context_params.pure_cli_mode    = true
+      DTK::Client::ContextRouter.routeTask(@entity_name, @method_name, new_context_params, @conn)
+    end
+
+    def self.is_candidate?(entity_name, args)
+      cli = formulate_command_string(entity_name, args)
+      if definitions = ROUTER_DATA[norm(entity_name)]
+        is_match = definitions.find { |d| cli.match(d[:regex]) }
+
+        return true if is_match
+      end
+
+      return false
+    end
+
+  private
+
+    def self.norm(string_value)
+      return string_value ? string_value.gsub('-','_').to_sym : nil
+    end
+
+    def self.formulate_command_string(entity_name, args)
+      "#{entity_name} #{args.join(' ')}".strip()
+    end
+  end
+end

data/lib/parser/adapters/thor.rb

@@ -329,6 +329,9 @@ module DTK
             unless response['data'].nil?
               identifiers = []
               response['data'].each do |element|
+                # special flag to filter out data not needed here
+                next if element['dtk_context_hidden']
+
                 identifiers << { :name => element['display_name'], :identifier => element['id'], :shadow_entity => element['dtk_client_type'] }
               end
               return identifiers

data/lib/shell.rb

@@ -60,7 +60,8 @@ def run_shell_command()
     #system('stty', stty_save) # Restore
     retry
   rescue Exception => e
-    DtkLogger.instance.error_pp("[CLI INTERNAL ERROR] #{e.message}", e.backtrace)
+    client_internal_error = DTK::Client::DtkError::Client.label()
+    DtkLogger.instance.error_pp("[#{client_internal_error}] #{e.message}", e.backtrace)
   ensure
     puts "\n" unless e.is_a? DTK::Shell::ExitSignal
     # logout

data/lib/shell/domain/context_params.rb

@@ -3,11 +3,13 @@ module DTK::Shell
 
     attr_accessor :current_context
     attr_accessor :method_arguments
+    attr_accessor :pure_cli_mode
 
     def initialize(override_method_arguments = [])
       @current_context  = ActiveContext.new
       @method_arguments = override_method_arguments
       @thor_options     = Hash.new
+      @pure_cli_mode    = false
 
       @method_arguments
     end

data/lib/util/console.rb

@@ -39,7 +39,7 @@ module DTK::Client
       def confirmation_prompt_simple(message, add_options=true)
         # used to disable skip with ctrl+c
         trap("INT", "SIG_IGN")
-        message += " (Y/n)" if add_options
+        message += " (y/n)" if add_options
 
         while line = Readline.readline("#{message}: ", true)
           if (line.eql?("yes") || line.eql?("y") || line.empty?)

data/lib/util/os_util.rb

@@ -295,6 +295,7 @@ module DTK
             load File.expand_path('../../lib/domain/git_adapter.rb', File.dirname(__FILE__))
             load File.expand_path('../../lib/command_helpers/git_repo.rb', File.dirname(__FILE__))
             load File.expand_path('../../lib/command_helpers/service_importer.rb', File.dirname(__FILE__))
+            load File.expand_path('../../lib/view_processor/table_print.rb', File.dirname(__FILE__))
             paths = []
             paths << File.expand_path('../../lib/commands/thor/*.rb', File.dirname(__FILE__))
             paths << File.expand_path('../../lib/commands/common/thor/*.rb', File.dirname(__FILE__))

data/lib/util/remote_dependency_util.rb

@@ -4,17 +4,19 @@
 module DTK
   module Client
     module RemoteDependencyUtil
-
       MODULE_REF_FILE = 'module_refs.yaml'
 
       class << self
-
-        def print_dependency_warnings(response, success_msg=nil)
+        def print_dependency_warnings(response, success_msg = nil, opts = {})
           are_there_warnings = false
           return are_there_warnings if response.nil? || response.data.nil?
 
           warnings = response.data['dependency_warnings']
           if warnings && !warnings.empty?
+            if opts[:ignore_permission_warnings]
+              warnings.delete_if { |warning| warning['error_type'].eql?('no_permission') }
+              return if warnings.empty?
+            end
             print_out "Following warnings have been detected for current module by Repo Manager:\n"
             warnings.each { |w| print_out("  - #{w['message']}") }
             puts
@@ -24,6 +26,21 @@ module DTK
           are_there_warnings
         end
 
+        def check_permission_warnings(response)
+          errors = ''
+          dependency_warnings = response.data['dependency_warnings']
+
+          if dependency_warnings && !dependency_warnings.empty?
+            no_permissions = dependency_warnings.select { |warning| warning['error_type'].eql?('no_permission') }
+
+            errors << "\n\nYou do not have (R) permissions for modules:\n\n"
+            no_permissions.each { |np| errors << "  - #{np['module_namespace']}:#{np['module_name']} (owner: #{np['module_owner']})\n" }
+            errors << "\nPlease contact owner(s) to change permissions for those modules."
+          end
+
+          raise DtkError, errors unless errors.empty?
+        end
+
         def module_ref_content(location)
           abs_location = File.join(location, MODULE_REF_FILE)
           File.exists?(abs_location) ? File.read(abs_location) : nil

data/lib/view_processor/table_print.rb

@@ -21,6 +21,11 @@ class DtkOpenStruct < OpenStruct
   end
 end
 
+# [Haris]
+# Elements with action column (taks status) have been removed since they are no longer in use. In case of bug that is relying
+# on existance of element and logic, please contact me to resolve it.
+#
+
 module DTK
   module Client
     class ViewProcTablePrint < ViewProcessor
@@ -41,6 +46,7 @@ module DTK
 
       def initialize(data, data_type, forced_metadata, print_error_table)
         # if there is no custom metadata, then we use metadata predefined in meta-response.json file
+
         if forced_metadata.nil?
           # get all table definitions from json file
           @table_defintions = get_metadata()
@@ -84,7 +90,7 @@ module DTK
           evaluated_element = DtkOpenStruct.new
           error_element     = DtkOpenStruct.new
 
-          # based on mappign we set key = eval(value)
+          # based on mapping we set key = eval(value)
           table_defintion.each do |k,v|
             begin
               # due to problems with space we have special way of handling error columns
@@ -124,29 +130,6 @@ module DTK
                   # add it with other
                   @error_data << error_element
                 end
-              elsif k.include?('action')
-                error_message = value_of(structured_element, v)
-
-                # here we see if there was an error if not we will skip this
-                # if so we add it to @error_data
-
-                if error_message.empty?
-                  # no error message just add it as regular element
-                  evaluated_element.send("#{k}=",value_of(structured_element, v))
-                else
-                  error_index = "[ #{value_of(structured_element,'logs.label')} ]" || ""
-                  error_type = value_of(structured_element,'logs.dtk_type') || ""
-
-                  # original table takes that index
-                  evaluated_element.send("#{k}=", error_index)
-
-                  # we set new error element
-                  error_element.id      = error_index
-                  error_element.message = error_message
-
-                  # add it with other
-                  @action_data << error_element
-                end
               else
                 evaluated_element.send("#{k}=", value_of(structured_element, v))
                 # eval "evaluated_element.#{k}=structured_element.#{v}"
@@ -161,7 +144,6 @@ module DTK
             end
           end
 
-          @order_definition.delete('action')
           @order_definition.delete('errors')
 
           @evaluated_data << evaluated_element