dtk-client 0.5.6.1

data/lib/shell/help_monkey_patch.rb

@@ -0,0 +1,221 @@
+class Thor
+  class << self
+    # NOTE: Class is loaded automaticly in dtk-shell
+
+    @@shell_context = nil
+    HIDE_FROM_BASE_CONTEXT_HELP = "HIDE_FROM_BASE"
+
+    def set_context(context)
+      @@shell_context = context
+    end
+
+    def match_help_item_changes(help_item, entity_name)
+      help_item.first.match(/^\[?#{entity_name.upcase}.?(NAME\/ID|ID\/NAME|ID|NAME)(\-?PATTERN)?\]?/)
+    end
+
+    def replace_if_matched!(help_item, matched)
+      # change by reference
+      help_item.first.gsub!(matched[0],'') if matched
+
+      return help_item
+    end
+
+    # Method returns alternative providers
+    def get_alternative_identifiers(command_name)
+      # we check for alternate identifiers
+      command_clazz = ::DTK::Client::OsUtil.get_dtk_class(command_name)
+
+      if (command_clazz && command_clazz.respond_to?(:alternate_identifiers))
+        return command_clazz.alternate_identifiers()
+      end
+
+      return []
+    end
+
+    # Monkey path of printable task methods to include name as well
+    # Returns tasks ready to be printed.
+    def printable_tasks(all = true, subcommand = false)
+      (all ? all_tasks : tasks).map do |_, task|
+        # using HIDE_FROM_BASE to hide command from base context help (e.g from dtk:/assembly>help) ...
+        # but show that command in other context help (e.g in dtk:/assembly/assembly_id/utils>help)
+        # added (task.name.eql?('help')) to hide help from command list
+        next if (task.hidden? || (task.name.eql?("help")) || (task.usage.include?(HIDE_FROM_BASE_CONTEXT_HELP) && (@@shell_context ? !@@shell_context.active_context.is_n_context? : '')))
+        item = []
+        item << banner(task, false, subcommand)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item << task.name
+        item
+      end.compact
+    end
+
+    # method will check if help is overriden and if so it will replace help description,
+    # with overriden one, override_tasks => class => OverrideTasks
+    def overriden_help(override_tasks, help_item, is_command)
+      return (override_tasks && override_tasks.are_there_self_override_tasks?) ? override_tasks.check_help_item(help_item, is_command) : help_item
+    end
+
+    def help(shell, subcommand = false)
+      list = printable_tasks(true, subcommand)
+
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_tasks(false)
+      end
+
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      # monkey patching here => START
+      if @@shell_context
+        unless @@shell_context.root?
+
+          # first command we are using:
+          # e.g. dtk:\assembly\assembly1\node\node123> => command would be :assembly
+          command             = @@shell_context.active_context.first_command_name.upcase
+
+          # is there identifier for given commands (first)
+          # e.g. dtk:\assembly\assembly1\node\node123> => identifier here would be 'assembly1'
+          is_there_identifier = @@shell_context.active_context.is_there_identifier_for_first_context?
+
+          # alternative providers
+          alt_identifiers = get_alternative_identifiers(command)
+
+          
+          filtered_list = []
+
+          # case when we are not on first level and it is not identifier we skip help 
+          # since it needs to be empty
+          # e.g. assembly/bootstrap1/node> ... HELP IS EMPTY FOR THIS
+
+
+          # override objects are special cases defined in Thor classes
+          # base on level there will be included in help context, help content is calculated by:
+          #
+          # 1) Matching help items with Regex (see bellow)
+          # 2) Adding help items from override_methods
+          #
+          #
+          override_tasks_obj = self.respond_to?(:override_allowed_methods) ? self.override_allowed_methods.dup : nil
+
+          # N-LEVEL-CONTEXT - context that has at least 2 commands and 1 or more identifiers
+          # e.g. dtk:\assembly\assembly1\node>         THIS IS     N-LEVEL CONTEXT
+          # e.g. dtk:\assembly\assembly1\node\node123> THIS IS     N-LEVEL CONTEXT
+          # e.g. dtk:\assembly\assembly1>              THIS IS NOT N-LEVEL CONTEXT
+          #
+          if (!@@shell_context.active_context.is_n_context? || @@shell_context.active_context.current_identifier?)
+
+            list.each do |help_item|
+              help_item.first.gsub!("^^", '') if help_item.first.include?("^^")
+              
+              # this will match entity_name (command) and alternative identifiers  
+              identifers = [command] + alt_identifiers
+
+              # matches identifiers for ID/NAME
+              matched_data          = help_item.first.match(/^\s\[?(#{identifers.join('|')}).?(NAME\/ID|ID\/NAME)\]?\s/)
+              alt_matched_data      = help_item.first.match(/^\s\[?(#{alt_identifiers.join('|')}).?(NAME\/ID|ID\/NAME)\]?\s/)
+        
+              if matched_data.nil?
+                # not found and tier 1 we add it to help list
+                filtered_list << overriden_help(override_tasks_obj, help_item, true) if @@shell_context.current_command?
+              else
+                # for help we only care about first context name / identifier
+                if !is_there_identifier
+                  # if it contains [] it is optional and will be available on both tiers
+                  if matched_data[0].include?('[')
+                    # we remove it, since there is no need to use it
+                    help_item.first.gsub!(matched_data[0],' ') unless help_item.nil?
+                    filtered_list << overriden_help(override_tasks_obj, help_item, true)
+                  end
+                else
+                  # Adding alt identifiers here
+                  if alt_matched_data
+                    if @@shell_context.active_context.current_alt_identifier?
+                      help_item.first.gsub!(matched_data[0],'') unless help_item.nil?
+                      filtered_list << overriden_help(override_tasks_obj, help_item, false)
+                    end
+                  else
+                    unless @@shell_context.active_context.current_alt_identifier?
+                      help_item.first.gsub!(matched_data[0],'') unless help_item.nil?
+                      filtered_list << overriden_help(override_tasks_obj, help_item, false)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # This will return commands that have identifiers
+          # e.g. dtk:\assembly\assembly1\node\node123> => ['assembly','node']
+          commands_that_have_identifiers =  @@shell_context.active_context.commands_that_have_identifiers()
+          is_n_level_context             = @@shell_context.active_context.command_list.size > 1
+
+          # first one does not count
+          if is_n_level_context
+            # additional filter list for n-context
+            n_filter_list = []
+            # we do not need first one, since above code takes care of that one
+            filtered_list = filtered_list.select do |filtered_help_item|
+              #next unless filtered_help_item
+              commands_that_have_identifiers[1..-1].each_with_index do |entity,i|                 
+                matched = match_help_item_changes(filtered_help_item, entity)
+                filtered_help_item = replace_if_matched!(filtered_help_item, matched)
+
+                # if it is last command, and there were changes                 
+                if (i == (commands_that_have_identifiers.size - 2) && matched)
+                  n_filter_list << filtered_help_item
+                end
+              end
+            end
+            
+            if override_tasks_obj && is_n_level_context
+              last_entity_name = @@shell_context.active_context.last_context_entity_name.to_sym
+
+              # we get commands task, and identifier tasks for given entity (e.g. :assembly)
+              command_o_tasks, identifier_o_tasks = override_tasks_obj.get_all_tasks(last_entity_name)
+
+              if @@shell_context.active_context.current_identifier?
+                identifier_o_tasks.each do |o_task|
+                  n_filter_list << [o_task[1],o_task[2]]
+                end
+              else
+                command_o_tasks.each do |o_task|
+                  n_filter_list << [o_task[1],o_task[2]]
+                end
+              end
+            end
+
+            # we have just filtered those methods that have attribute for given entity 
+            # and also are last in the list
+            filtered_list = n_filter_list
+          end
+
+          # remove double spaces
+          list = filtered_list.each { |e| e.first.gsub!(/  /,' ') }
+        end
+      else
+        # no dtk-shell just dtk, we make sure that underscore is not used '_'
+        list = list.collect do |item|
+
+          #
+          # e.g.
+          # dtk assembly_template info 
+          # dtk assembly-template info
+          #
+          item[0] = item[0].gsub(/^dtk ([a-zA-Z]+)_([a-zA-Z]+) /,'dtk \1-\2 ')
+          item
+        end
+      end
+
+      if list.empty?
+        shell.say ""
+        shell.say "No tasks for current context '#{@@shell_context.active_context.full_path}'." 
+      end
+
+      # remove helper 3. element in help item list
+      list = list.collect { |e| e[0..1] }
+
+      # monkey patching here => END
+      shell.print_table(list, :indent => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+  end
+end

data/lib/shell/interactive_wizard.rb

@@ -0,0 +1,233 @@
+require 'colorize'
+require 'readline'
+
+module DTK
+  module Shell
+
+
+    # we use interactive wizard to give user opertunity
+    class InteractiveWizard
+
+      PP_LINE_HEAD  = '--------------------------------- DATA ---------------------------------'
+      PP_LINE       = '------------------------------------------------------------------------'
+      INVALID_INPUT = Client::OsUtil.colorize(" Input is not valid.", :yellow)
+      EC2_REGIONS   = ['us-east-1','us-west-1','us-west-2','eu-west-1','sa-east-1','ap-northeast-1','ap-southeast-1','ap-southeast-2' ]
+      
+
+      def initialize
+      end
+
+      def self.validate_region(region)
+        unless EC2_REGIONS.include? region
+          raise ::DTK::Client::DtkValidationError.new("Region '#{region}' is not EC2 region, use one of: #{EC2_REGIONS.join(',')}") 
+        end
+      end
+
+      # Generic wizard which will return hash map based on metadata input
+      def self.interactive_user_input(wizard_dsl, recursion_call = false)
+        results = {}
+        
+        begin
+          wizard_dsl.each do |meta_input|
+            input_name = meta_input.keys.first
+            display_name = input_name.to_s.gsub(/_/,' ')
+            metadata = meta_input.values.first
+            case metadata[:type]
+              when nil
+                output = recursion_call ? "#{display_name.capitalize}: " : "Enter value for '#{display_name}': "
+                validation = nil
+              when :question
+                output = "#{metadata[:question]} (#{metadata[:options].join('|')}): "
+                validation = 
+                metadata[:options]
+              when :selection
+                options = ""
+                display_field = metadata[:display_field]
+                metadata[:options].each_with_index do |o,i|
+                  if display_field
+                    options += "\t#{i+1}. #{o[display_field]}\n"
+                  else
+                    options += "\t#{i+1}. #{o}\n"
+                  end
+                end
+                options += DTK::Client::OsUtil.colorize("\t0. Skip\n", :yellow) if metadata[:skip_option]
+                output = "Select '#{display_name}': \n\n #{options} \n "
+                validation_range_start = metadata[:skip_option] ? 0 : 1
+                validation = (validation_range_start..metadata[:options].size).to_a
+              when :group
+                # recursion call to populate second level of hash params
+                puts " Enter '#{display_name}' details: "
+                results[input_name] = self.interactive_user_input(metadata[:options], true)
+                next
+            end
+
+            input = resolve_input(output,validation,!metadata[:optional],recursion_call)
+
+            if metadata[:required_options] && !metadata[:required_options].include?(input)
+              # case where we have to give explicit permission, if answer is not affirmative
+              # we terminate rest of the wizard
+              DTK::Client::OsUtil.print(" #{metadata[:explanation]}", :red)
+              return nil
+            end
+
+            # post processing
+            if metadata[:type] == :selection
+              input = input.to_i == 0 ? nil : metadata[:options][input.to_i - 1]
+            end
+
+            results[input_name] = input
+          end
+
+          return results
+        rescue Interrupt => e
+          puts
+          raise DTK::Client::DtkValidationError, "Exiting the wizard ..."
+        end
+      end
+
+
+      def self.resolve_input(output, validation, is_required, is_recursion_call)
+        tab_prefix = is_recursion_call ? "\t" : ""
+
+        # there was a bug within windows that does not support multiline input in readline method
+        # following is the fix
+        prompt_input =  " #{tab_prefix}#{output}"
+        if output.match(/\n/)
+          puts prompt_input
+          prompt_input = ">> "
+        end
+        
+        while line = Readline.readline(prompt_input, true)
+          if is_required && line.empty?
+            puts INVALID_INPUT
+            next
+          end
+
+          if !validation || validation.find { |val| line.eql?(val.to_s) }
+            return line
+          end
+
+          puts INVALID_INPUT
+        end
+      end
+
+
+
+      # takes hash maps with description of missing params and
+      # returns array of hash map with key, value for each missed param
+      def self.resolve_missing_params(param_list)
+        begin
+          user_provided_params, checkup_hash = [], {}
+
+          puts "\nPlease fill in missing data.\n"
+          param_list.each do |param_info|
+            description =
+              if param_info['display_name'] =~ Regexp.new(param_info['description'])
+                param_info['display_name']
+              else 
+                "#{param_info['display_name']} (#{param_info['description']})"
+              end
+            datatype_info = (param_info['datatype'] ? DTK::Client::OsUtil.colorize(" [#{param_info['datatype'].upcase}]", :yellow) : '')
+            string_identifier = DTK::Client::OsUtil.colorize(description, :green) + datatype_info
+
+            puts "Please enter #{string_identifier}:"
+            while line = Readline.readline(": ", true)
+              id = param_info['id']
+              user_provided_params << {:id => id, :value => line}
+              checkup_hash[id] = {:value => line, :description => description}
+              break
+            end
+            
+          end
+
+          # pp print for provided parameters
+          pretty_print_provided_user_info(checkup_hash)
+
+          # make sure this is satisfactory
+          while line = Readline.readline("Is provided information ok? (yes|no) ", true)
+            # start all over again
+            return resolve_missing_params(param_list) if 'no'.eql? line 
+            # continue with the code
+            break if 'yes'.eql? line
+          end
+
+        rescue Interrupt => e
+          puts
+          # TODO: Provide original error here 
+          raise DTK::Client::DtkError, "You have decided to skip correction wizard."
+        end
+
+        return user_provided_params
+      end
+
+      private
+
+      def self.pretty_print_provided_user_info(user_information)
+        puts PP_LINE_HEAD
+        user_information.each do |key,info|
+          description = info[:description]
+          value = info[:value]
+          printf "%48s : %s\n", DTK::Client::OsUtil.colorize(description, :green), DTK::Client::OsUtil.colorize(value, :yellow)
+        end
+        puts PP_LINE
+        puts
+      end
+    end
+  end
+end
+
+## EXAMPLE OF USAGE
+
+# Example 1. Creating target via wizard
+=begin
+    desc "create","Wizard that will guide you trough creation of target and target-template"
+    def create(context_params)
+      
+      # we get existing templates
+      target_templates = post rest_url("target/list"), { :subtype => :template }
+
+      # ask user to select target template
+      wizard_params = [{:target_template => { :type => :selection, :options => target_templates['data'], :display_field => 'display_name', :skip_option => true }}]
+      target_template_selected = DTK::Shell::InteractiveWizard.interactive_user_input(wizard_params)
+      target_template_id = (target_template_selected[:target_template]||{})['id']
+
+      wizard_params = [
+        {:target_name     => {}},
+        {:description      => {:optional => true }}
+      ]
+
+      if target_template_id.nil?
+        # in case user has not selected template id we will needed information to create target
+        wizard_params.concat([
+          {:iaas_type       => { :type => :selection, :options => [:ec2] }},
+          {:aws_install     => { :type => :question, 
+                                 :question => "Do we have your permission to add necessery 'key-pair' and 'security-group' to your EC2 account?", 
+                                 :options => ["yes","no"], 
+                                 :required_options => ["yes"],
+                                 :explanation => "This permission is necessary for creation of a custom target."
+                                }},
+          {:iaas_properties => { :type => :group, :options => [
+              {:key    => {}},
+              {:secret => {}},
+              {:region => {:type => :selection, :options => DTK::Shell::InteractiveWizard::EC2_REGIONS}},
+          ]}},
+        ])
+      end
+
+      post_body = DTK::Shell::InteractiveWizard.interactive_user_input(wizard_params)
+      post_body ||= {}
+
+      # this means that user has not given permission so we skip request
+      return unless (target_template_id || post_body[:aws_install])
+
+      # in case user chose target ID
+      post_body.merge!(:target_template_id => target_template_id) if target_template_id
+
+
+      response = post rest_url("target/create"), post_body
+       # when changing context send request for getting latest targets instead of getting from cache
+      @@invalidate_map << :target
+
+      return response
+    end
+=end

data/lib/shell/parse_monkey_patch.rb

@@ -0,0 +1,22 @@
+class Thor
+  class Options < Arguments #:nodoc:
+
+    protected
+
+      def parse_boolean(switch)
+        if current_is_value?
+          if ["true", "TRUE", "t", "T", true].include?(peek)
+            # shift
+            true
+          elsif ["false", "FALSE", "f", "F", false].include?(peek)
+            # shift
+            true
+          else
+            true
+          end
+        else
+          @switches.key?(switch) || !no_or_skip?(switch)
+        end
+      end
+  end
+end

data/lib/shell/status_monitor.rb

@@ -0,0 +1,105 @@
+require 'thread'
+require 'singleton'
+require 'colorize'
+#dtk_require('../commands')
+
+# This singleton is used to check status on running processes on the server side
+# Once certain task is complete it will give notice to user da certain task has been completed
+# At the moment this only 
+
+module DTK
+  module Shell
+    class TaskStatusThread < Thread
+      attr_accessor :task_id, :finished, :status
+
+      def initialize
+        @finished = false
+        super
+      end
+    end
+
+    class StatusMonitor
+      include Singleton
+      include DTK::Client::CommandBase
+
+      THREAD_SLEEP_TIME = DTK::Configuration.get(:task_check_frequency)
+
+      def initialize
+        @threads        = []
+        @finished_tasks = []
+        @conn           = DTK::Client::Session.get_connection()
+      end
+
+      def self.start_monitoring(task_id)
+        self.instance.start_monitoring(task_id)
+      end
+
+      def self.check_status
+        self.instance.check_status
+      end
+
+      def check_status
+        @threads.each do |t|
+          if t.finished
+            @finished_tasks << t
+          end
+        end
+
+        # removes finished tasks from the main queue
+        @threads = @threads - @finished_tasks
+
+        @finished_tasks.each do |t|
+          puts ""
+          puts "[TASK NOTICE] Task with ID: #{t.task_id}, has finished with status: #{colorize_status(t.status)}"
+        end
+
+        @finished_tasks.clear
+      end
+
+      def start_monitoring(task_id)
+        puts "Client has started monitoring task [ID:#{task_id}]. You will be notified when task has been completed."
+        @threads << DTK::Shell::TaskStatusThread.new do
+          begin
+            response, post_hash_body = nil, {}
+            post_hash_body[:task_id] = task_id
+            DTK::Shell::TaskStatusThread.current.task_id = task_id
+
+            # pooling server for task status
+            while task_running?(response)
+              sleep(THREAD_SLEEP_TIME) unless response.nil?
+              response = post rest_url("task/status"),post_hash_body
+              # we break if there is error in response
+              break unless response.ok?
+            end
+            
+            DTK::Shell::TaskStatusThread.current.finished = true
+
+            if response.ok?
+              DTK::Shell::TaskStatusThread.current.status = response.data['status'].upcase
+            else                
+              DTK::Shell::TaskStatusThread.current.status = "RESPONSE NOT OK, RESPONSE: #{response}"
+            end
+
+          rescue Exception => e
+            DtkLogger.instance.error_pp("[THREAD ERROR] Error getting task status with message: #{e.message}", e.backtrace)
+          end
+        end
+      end
+
+      private
+
+      def colorize_status(status)
+        color = status.eql?('FAILED') ? :red : :green
+        return DTK::Client::OsUtil.colorize(status, color)
+      end
+
+      # return true   if status SUCCEDED, FAILED
+      # returns false if status EXECUTING
+      def task_running?(response)
+        return true if response.nil?
+        return !(response.data['status'].eql?("succeeded") || response.data['status'].eql?("failed"))
+      end
+
+    end
+  end
+end