dtk-client 0.6.8 → 0.7.0

data/lib/domain/response.rb

@@ -52,17 +52,23 @@ module DTK
       end
 
       def get_label_for_column_name(column, type)
-        mappings = {
-          "#{type}_id:" => "ID:", 
-          "#{type}_name:" => "NAME:", 
-          "node_type:" => "TYPE:", 
-          "instance_id:" => "INSTANCE ID:",
-          "size:" => "SIZE:",
-          "os_type:" => "OS:",
-          "op_status:" => "OP STATUS:",
-          "dns_name:" => "DNS NAME:",
-          "target:" => "TARGET:"
-        }
+        if type.eql?('node')
+          mappings = {
+            column => column
+          }
+        else
+          mappings = {
+            "#{type}_id:" => "ID:",
+            "#{type}_name:" => "NAME:",
+            "node_type:" => "TYPE:",
+            "instance_id:" => "INSTANCE ID:",
+            "size:" => "SIZE:",
+            "os_type:" => "OS:",
+            "op_status:" => "OP STATUS:",
+            "dns_name:" => "DNS NAME:",
+            "target:" => "TARGET:"
+          }
+        end
         
         mappings[column]
       end
@@ -73,7 +79,7 @@ module DTK
         if type.eql?("component")
           info_list = ["component_name","component_id","basic_type","description"]
         else
-          info_list = ["node_id", "node_name","os_type", "instance_id", "op_status", "size", "target", "dns_name"]
+          info_list = ["type", "node_id", "node_name","os_type", "instance_id", "admin_op_status", "size", "target", "dns_name", "image_id", "ec2_public_address", "privete_dns_name", "keypair", "security_groups", "security_group", "security_group_set"]
         end
 
         columns = []
@@ -91,7 +97,13 @@ module DTK
           end
         end
 
-        columns.sort!()
+        if type.eql?('node')
+          # move target from first place
+          columns.rotate!
+        else
+          columns.sort!()
+        end
+
         columns.each do |column|
           STDOUT << column
         end 

data/lib/dtk-client/version.rb

@@ -1,3 +1,3 @@
 module DtkClient
-  VERSION="0.6.8"
+  VERSION="0.7.0"
 end

data/lib/parser/adapters/thor.rb

@@ -10,6 +10,7 @@ dtk_require("../../util/console")
 dtk_require_common_commands('thor/task_status')
 dtk_require_from_base("command_helper")
 dtk_require("../../context_router")
+dtk_require_common_commands('thor/poller')
 
 module DTK
   module Client
@@ -17,10 +18,12 @@ module DTK
       dtk_nested_require('thor','common_option_defs')
 
       include CommandBase
+      include CommandHelperMixin
+      include Poller
+
       extend  CommandBase
       extend  TaskStatusMixin
       extend  Console
-      include CommandHelperMixin
       extend CommonOptionDefs::ClassMixin
 
       @@cached_response = {}
@@ -74,7 +77,7 @@ module DTK
             if action['wait_for_complete']
               entity_id, entity_type = action['wait_for_complete']['id'].to_s, action['wait_for_complete']['type']
               puts "Waiting for task to complete ..."
-              task_status_aux(entity_id,entity_type,true)
+              task_status_aux(entity_id,entity_type,:wait => true)
             end
           else
             # validation action are being skipped
@@ -326,7 +329,7 @@ module DTK
             unless response['data'].nil?
               identifiers = []
               response['data'].each do |element|
-                identifiers << { :name => element['display_name'], :identifier => element['id'] }
+                identifiers << { :name => element['display_name'], :identifier => element['id'], :shadow_entity => element['dtk_client_type'] }
               end
               return identifiers
             end
@@ -403,7 +406,7 @@ module DTK
 
           match = nil
           response = self.class.get_cached_response(entity_type,list_command_path,subtype)
-          if response.ok? and response['data']
+          if response and response.ok? and response['data']
             match = response['data'].find{|entity|entity_id == entity['id']}
           end
           unless match
@@ -428,7 +431,7 @@ module DTK
 
         # removes nil values
         def post_body(hash)
-          hash.inject(Hash.new){|h,(k,v)|v.nil? ? h : h.merge(k => v)} 
+          hash.inject(Hash.new){|h,(k,v)|v.nil? ? h : h.merge(k => v)}
         end
 
         # User input prompt

data/lib/shell/context.rb

@@ -351,7 +351,7 @@ module DTK
               break
             end
 
-            active_context_copy.push_new_context(context_hash_data[:name], command, context_hash_data[:identifier]) if ((i+1) >= ac_size)
+            active_context_copy.push_new_context(context_hash_data[:name], command, context_hash_data[:identifier], context_hash_data[:shadow_entity]) if ((i+1) >= ac_size)
           end
         end
 
@@ -512,8 +512,12 @@ module DTK
         # so getting context for 'public' will not work and we use than library
         command_name = root? ? 'dtk' : @active_context.last_command_name
 
-        # if there is no new context (current) we use old one
-        @current = current_context_task_names() || @current
+        if @active_context.last_context_is_shadow_entity?
+          @current = ShadowEntity.resolve_tasks(@active_context.last_context)
+        else
+          # if there is no new context (current) we use old one
+          @current = current_context_task_names() || @current
+        end
 
         client_commands = CLIENT_COMMANDS
         client_commands.concat(DEV_COMMANDS) if DTK::Configuration.get(:development_mode)
@@ -530,6 +534,7 @@ module DTK
         command_name_list = command_context ? command_context.collect { |e| e[:name] } : []
         @context_commands.concat(command_name_list) if current_command?
 
+
         # logic behind context loading
         #Readline.completer_word_break_characters=" "
         Readline.completion_proc = proc { |input| dynamic_autocomplete_context(input, Readline.respond_to?("line_buffer") ? Readline.line_buffer : [])}
@@ -798,22 +803,6 @@ module DTK
         candidates
       end
 
-      # changes command and argument if argument is plural of one of
-      # the possible commands on tier1 e.g. libraries, assemblies
-      # return 2 values cmd, args
-      def reverse_commands(cmd, args)
-        # iterates trough current context available commands
-        @current.each do |available_commands|
-          # singulirazes command, e.g. libraries => library
-          command_singular=args.first.singularize
-          if available_commands.eql?(command_singular)
-            cmd, args = command_singular, [cmd]
-          end
-        end
-
-        return cmd, args
-      end
-
       def get_dtk_command_parameters(entity_name, args)
         method_name, entity_name_id = nil, nil
         context_params = ContextParams.new

data/lib/shell/domain/active_context.rb

@@ -0,0 +1,169 @@
+module DTK::Shell
+  class ActiveContext
+
+    # special case when we are not able to provide valid identifier but we are
+    # using it as such
+    NO_IDENTIFIER_PROVIDED = -1
+
+    # TODO: Remove accessor for debug purpose only
+    attr_accessor :context_list
+
+    def clone_me()
+      inst = ActiveContext.new
+      inst.context_list = @context_list.clone
+      return inst
+    end
+
+    def initialize
+      @context_list = []
+    end
+
+    def push_new_context(context_name, entity_name, context_value=nil, shadow_entity=nil)
+      @context_list << ContextEntity.create_context(context_name, entity_name, context_value, :id, shadow_entity)
+    end
+
+    def push_new_name_context(context_name, entity_name, context_value=nil)
+      @context_list << ContextEntity.create_context(context_name, entity_name, context_value, :name)
+    end
+
+    def pop_context(n)
+      return @context_list.pop(n)
+    end
+
+    def find_identifier(entity_name)
+      results = @context_list.select { |e| (e.is_identifier? && (e.entity == entity_name.to_sym))}
+      return results.first
+    end
+
+    def find_command(entity_name)
+      results = @context_list.select { |e| (e.is_command? && (e.entity == entity_name.to_sym))}
+      return results.first
+    end
+
+    def name_list()
+      @context_list.collect { |e|  e.is_alt_identifier? ? e.transform_alt_identifier_name : e.name }
+    end
+
+    def name_list_simple()
+      @context_list.collect { |e|  e.name }
+    end
+
+
+    # returns list of entities that have identifier
+    def commands_that_have_identifiers()
+      filtered_entities = @context_list.select { |e| e.is_identifier? }
+      return filtered_entities.collect { |e| e.entity.to_s }
+    end
+
+    def command_list()
+      filtered_entities = @context_list.select { |e| e.is_command? }
+      return filtered_entities.collect { |e| e.entity.to_s }
+    end
+
+    # returns id to be used to retrive task list form the cache based on
+    # current active context
+    def get_task_cache_id()
+      identifier = command_list().join('_')
+      return 'dtk' if identifier.empty?
+      if current_alt_identifier?
+        return "#{identifier}_#{current_alt_identifier_name()}".to_sym()
+      end
+
+      return current_identifier? ? "#{identifier}_wid".to_sym : identifier.to_sym
+    end
+
+    def full_path()
+      path = name_list().join('/')
+      path = Context.enchance_path_with_alias(path, @context_list)
+
+      return "/#{path}"
+    end
+
+    def clear()
+      @context_list.clear
+    end
+
+    def empty?()
+      return @context_list.empty?
+    end
+
+    def is_n_context?
+      @context_list.size > 2
+    end
+
+    def is_base_context?
+      @context_list.size == 1
+    end
+
+    def is_root_context?
+      @context_list.size == 0
+    end
+
+    def current_command?
+      return @context_list.empty? ? true : @context_list.last.is_command?
+    end
+
+    def current_identifier?
+      return @context_list.empty? ? false : @context_list.last.is_identifier?
+    end
+
+    def current_alt_identifier?
+      return @context_list.empty? ? false : @context_list.last.is_alt_identifier?
+    end
+
+    def current_alt_identifier_name
+      @context_list.last.alt_identifier
+    end
+
+    def first_command_name()
+      @context_list.each do |e|
+        return e.name if e.is_command?
+      end
+
+      return nil
+    end
+
+    def is_there_identifier_for_first_context?
+      @context_list.each { |e| return true if e.is_identifier? }
+      return false
+    end
+
+    def last_command_name()
+      @context_list.reverse.each do |e|
+        return e.name if e.is_command?
+      end
+
+      return nil
+    end
+
+    def last_context_entity_name()
+      return @context_list.empty? ? nil : @context_list.last.entity
+    end
+
+    def last_context_name()
+      return @context_list.empty? ? nil : @context_list.last.name
+    end
+
+    def first_context_name()
+      return @context_list.empty? ? nil : @context_list.first.name
+    end
+
+    def first_context()
+      return @context_list.empty? ? nil : @context_list.first
+    end
+
+    def last_context()
+      return @context_list.empty? ? nil : @context_list.last
+    end
+
+    def last_context_is_shadow_entity?
+      return false if @context_list.empty?
+      !!last_context().shadow_entity
+    end
+
+    def shadow_entity()
+      return if @context_list.empty?
+      last_context().shadow_entity
+    end
+  end
+end

data/lib/shell/domain/context_entity.rb

@@ -0,0 +1,72 @@
+module DTK::Shell
+  class ContextEntity
+    attr_accessor   :entity
+    attr_accessor   :name
+    attr_accessor   :identifier
+    attr_accessor   :alt_identifier
+    attr_accessor   :shadow_entity
+
+    SHELL_SEPARATOR = '/'
+
+    def self.create_context(context_name, entity_name, context_value=nil, type_id=:id, shadow_entity=nil)
+      if context_value
+        if :id.eql?(type_id)
+          return ContextEntity.create_identifier(context_name, entity_name, context_value, shadow_entity)
+        else
+          return ContextEntity.create_name_identifier(context_name, entity_name, context_value, shadow_entity)
+        end
+      else
+        return ContextEntity.create_command(context_name, entity_name, shadow_entity)
+      end
+    end
+
+    def is_identifier?
+      return !@identifier.nil?
+    end
+
+    def is_alt_identifier?
+      return !@alt_identifier.nil?
+    end
+
+    def is_command?
+      return @identifier.nil?
+    end
+
+    def get_identifier(type)
+      return (type == 'id' ? self.identifier : self.name)
+    end
+
+    def transform_alt_identifier_name()
+      @name.gsub(::DTK::Client::CommandBaseThor::ALT_IDENTIFIER_SEPARATOR, SHELL_SEPARATOR)
+    end
+
+    private
+
+    def self.create_command(name, entity_name, shadow_entity=nil)
+      instance = ContextEntity.new
+      instance.name   = name
+      instance.entity = entity_name.to_sym
+      instance.shadow_entity = shadow_entity
+      return instance
+    end
+
+    def self.create_name_identifier(name, entity_name, value, shadow_entity=nil)
+      instance            = self.create_command(name,entity_name)
+      instance.name           = value
+      instance.identifier     = value
+      instance.alt_identifier = value
+      instance.shadow_entity = shadow_entity
+
+      return instance
+    end
+
+    def self.create_identifier(name, entity_name, value, shadow_entity=nil)
+      instance                = self.create_command(name,entity_name)
+      instance.identifier     = value
+      alt_identifier_name = name.to_s.split(::DTK::Client::CommandBaseThor::ALT_IDENTIFIER_SEPARATOR)
+      instance.alt_identifier = alt_identifier_name.size > 1 ? alt_identifier_name.first : nil
+      instance.shadow_entity  = shadow_entity
+      return instance
+    end
+  end
+end

data/lib/shell/domain/context_params.rb

@@ -0,0 +1,202 @@
+module DTK::Shell
+  class ContextParams
+
+    attr_accessor :current_context
+    attr_accessor :method_arguments
+
+    def initialize(override_method_arguments = [])
+      @current_context  = ActiveContext.new
+      @method_arguments = override_method_arguments
+      @thor_options     = Hash.new
+    end
+
+    def add_context_to_params(context_name, entity_name, context_value = nil)
+      @current_context.push_new_context(context_name, stand_name(entity_name), context_value)
+    end
+
+    def add_context_name_to_params(context_name, entity_name, context_value = nil)
+      @current_context.push_new_name_context(context_name, stand_name(entity_name), context_value)
+    end
+
+    def forward_options(options)
+      @thor_options = options
+    end
+
+    def get_forwarded_options()
+      @thor_options
+    end
+
+    def get_forwarded_thor_option(option_key)
+      return @thor_options ? @thor_options[option_key] : nil
+    end
+
+    def override_method_argument!(key, value)
+      id = match_argument_id(key)
+      raise DTK::Client::DtkImplementationError, "Wrong identifier used '#{key}', ID not matched!" unless id
+      @method_arguments[id] = value
+    end
+
+    # can be class methods but no need, since we have this instance available in each method
+    def retrieve_thor_options(mapping, options)
+      results = []
+      errors  = []
+
+      mapping.each do |key|
+        required = key.to_s.match(/.+!$/)
+        thor_key = key.to_s.gsub('!','')
+
+        results << element = options[thor_key]
+
+        if required && element.nil?
+          errors << thor_key
+        end
+      end
+
+      unless errors.empty?
+        raise DTK::Client::DtkValidationError.new("Missing required option#{errors.size > 1 ? 's' : ''}: #{errors.join(', ')}", true)
+      end
+
+      return ((results.size == 1) ? results.first : results)
+    end
+
+    def retrieve_arguments(mapping, method_info = [])
+      results = []
+      errors  = []
+
+      # using context_name when have array as key_mapping [:assembly_id, :workspace_id]
+      # to determine which context is used
+      context_name = method_info.first.split('-').first unless method_info.empty?
+
+      mapping.each do |key_mapping|
+
+        is_array = key_mapping.is_a?(Array)
+
+        selected_key = is_array ? key_mapping.first : key_mapping
+
+        required = selected_key.to_s.match(/.+!$/)
+
+        element = nil
+        matched = selected_key.to_s.match(/option_([0-9]+)/)
+        if matched
+          id = matched[1].to_i - 1
+          element = @method_arguments[id]
+
+          # used if last parameter has more than one word
+          # e.g. set-attribute attr_name "some value" (thor separates 'some value' as two parameters but we need it as one)
+          if(mapping.last.to_s.eql?(key_mapping.to_s))
+            new_id = id+1
+            while @method_arguments[new_id] do
+              element << " #{@method_arguments[new_id]}"
+              new_id += 1;
+            end
+          end
+
+          unless method_info.empty?
+            unless element
+              errors << method_info[id] if required
+            end
+          end
+
+        else
+          # More complex split regex for extracting entitiy name from mapping due to complex context names
+          # i.e. assembly-template will have assembly_template_id mapping
+          element = check_context_for_element(selected_key)
+
+          # if we are dealing with array we need to check rest of the keys since it is OR
+          # approach if first element not found take second
+          if element.nil? && is_array
+            key_mapping[1..-1].each do |alternative_key|
+              element = check_context_for_element(alternative_key)
+              break if element
+              if context_name
+                if alternative_key.to_s.include?(context_name.downcase)
+                  required = alternative_key.to_s.match(/.+!$/)
+                  selected_key = alternative_key
+                end
+              end
+            end
+          end
+
+          unless element
+            errors << "#{entity_name(selected_key).upcase} ID/NAME" if required
+          end
+        end
+
+        results << element
+      end
+
+      unless errors.empty?
+        raise DTK::Client::DtkValidationError.new("Missing required argument#{errors.size > 1 ? 's' : ''}: #{errors.join(', ')}", true)
+      end
+
+      return ((results.size == 1) ? results.first : results)
+    end
+
+    def is_last_command_eql_to?(command_name)
+      return @current_context.last_command_name() == command_name.to_s
+    end
+
+    def is_there_identifier?(entity_name)
+      return @current_context.find_identifier(entity_name) != nil
+    end
+
+    def is_there_command?(entity_name)
+      return @current_context.find_command(entity_name) != nil
+    end
+    def current_command?
+      return @current_context.current_command?
+    end
+    def root_command_name
+      @current_context.first_command_name
+    end
+    def last_entity_name
+      @current_context.last_context_entity_name
+    end
+    def shadow_entity_name()
+      @current_context.shadow_entity()
+    end
+
+    private
+
+    # matches argument id (integer) from used identifier (symbol)
+    #
+    # Returns: Integer as ID , or nil if not found
+    def match_argument_id(identifier)
+      matched = identifier.to_s.match(/option_([0-9]+)/)
+      (matched ? matched[1].to_i - 1 : nil)
+    end
+
+    # based on map key binding e.g. assembly_id, assembly_name we will extrace value
+    # from our ActiveContext
+    def check_context_for_element(key_mapping)
+      split_info  =  split_info(key_mapping)
+      entity_name =  entity_name(key_mapping,split_info)
+      id_type     = split_info[1].gsub(/!/,'')   # for required elements we remove '!' required marker
+      context_identifier = @current_context.find_identifier(entity_name)
+      if context_identifier
+        return context_identifier.get_identifier(id_type)
+      else
+        return nil
+      end
+    end
+
+    def entity_name(key_mapping,split_info=nil)
+      split_info ||= split_info(key_mapping)
+      split_info[0].gsub(/_/,'-')  # makes sure we are using entity names with '_'
+    end
+
+    #
+    # Standardize context name since we are in domain treating :component_module as :'component-module'
+    # and need to be careful about these changes
+    #
+
+    def stand_name(name)
+      name.to_s.gsub('_','-').to_sym
+    end
+
+    def split_info(key_mapping)
+      key_mapping.to_s.split(/_([a-z]+!?$)/)
+    end
+
+  end
+end

data/lib/shell/domain/override_tasks.rb

@@ -0,0 +1,71 @@
+module DTK
+  module Shell
+
+    class CachedTasks < Hash
+    end
+
+    class OverrideTasks < Hash
+
+      attr_accessor :completed_tasks
+      attr_accessor :always_load_list
+
+
+      # help_item (Thor printable task), structure:
+      # [0] => task defintion
+      # [1] => task description
+      # [2] => task name
+
+      # overriden_task (DTK override task), structure:
+      # [0] => task name
+      # [1] => task defintion
+      # [2] => task description
+
+      # using 'always load listed' to skip adding task to completed tasks e.g load utils for workspace and workspace_node
+      def initialize(hash=nil, always_load_listed=[])
+        super(hash)
+        @completed_tasks = []
+        @always_load_list = always_load_listed
+        self.merge!(hash)
+      end
+
+      # returns true if there are overrides for tasks on first two levels.
+      def are_there_self_override_tasks?
+        return (self[:all][:self] || self[:command_only][:self] || self[:identifier_only][:self])
+      end
+
+      def check_help_item(help_item, is_command)
+        command_tasks, identifier_tasks = get_all_tasks(:self)
+        found = []
+
+        if is_command
+          found = command_tasks.select { |o_task| o_task[0].eql?(help_item[2]) }
+        else
+          found = identifier_tasks.select { |o_task| o_task[0].eql?(help_item[2]) }
+        end
+
+        # if we find self overriden task we remove it
+        # [found.first[1],found.first[2],found.first[0]] => we convert from o_task structure to thor help structure
+        return found.empty? ? help_item : [found.first[1],found.first[2],found.first[0]]
+      end
+
+      # returns 2 arrays one for commands and next one for identifiers
+      def get_all_tasks(child_name)
+        command_o_tasks, identifier_o_tasks = [], []
+        command_o_tasks    = (self[:all][child_name]||[]) + (self[:command_only][child_name]||[])
+        identifier_o_tasks = (self[:all][child_name]||[]) + (self[:identifier_only][child_name]||[])
+        return command_o_tasks, identifier_o_tasks
+      end
+
+      def is_completed?(child_name)
+        # do not add task to completed if explicitly said to always load that task
+        return false if @always_load_list.include?(child_name)
+        @completed_tasks.include?(child_name)
+      end
+
+      def add_to_completed(child_name)
+        @completed_tasks << child_name
+      end
+    end
+
+  end
+end