dtk-client 0.5.6.1

data/lib/commands/common/thor/task_status.rb

@@ -0,0 +1,81 @@
+module DTK::Client
+  module TaskStatusMixin
+      def task_status_aux(id,type,wait_flag)
+        id_field = "#{type}_id".to_sym
+        if wait_flag
+          # there will be infinite loop until intereputed with CTRL+C
+          begin
+            response = nil
+            loop do 
+              post_body = {
+                id_field => id,
+                :format => :table
+              }
+              response = post rest_url("#{type}/task_status"), post_body                                       
+
+              raise DTK::Client::DtkError, "[ERROR] #{response['errors'].first['message']}." if response["status"].eql?('notok')
+
+              # stop pulling when top level task succeds, fails or timeout
+              if response and response.data and response.data.first
+                #TODO: may fix in server, but now top can have non executing state but a concurrent branch can execute; so
+                #chanding bloew for time being
+                #break unless response.data.first["status"].eql? "executing"
+                # TODO: There is bug where we do not see executing status on start so we have to wait until at 
+                # least one 'successed' has been found
+                is_pending   = (response.data.select {|r|r["status"].nil? }).size > 0
+                is_executing = (response.data.select {|r|r["status"].eql? "executing"}).size > 0
+                is_failed    = (response.data.select {|r|r["status"].eql? "failed"}).size > 0
+                is_cancelled = response.data.first["status"].eql?("cancelled")
+                
+                # when some of the converge tasks fail, stop task-status --wait and set task status to '' for remaining tasks which are not executed
+                if is_failed
+                  response.data.each {|r| (r["status"] = "") if r["status"].eql?("executing")}
+                  is_cancelled = true
+                end
+                
+                unless (is_executing || is_pending) && !is_cancelled
+                  system('clear')
+                  response.print_error_table = true
+                  response.render_table(:task_status)
+                  return response
+                end
+              end
+
+              response.render_table(:task_status)
+              system('clear')
+              response.render_data(true)
+
+              Console.wait_animation("Watching '#{type}' task status [ #{DEBUG_SLEEP_TIME} seconds refresh ] ",DEBUG_SLEEP_TIME)
+            end
+          rescue Interrupt => e
+            puts ""
+            # this tells rest of the flow to skip rendering of this response
+            response.skip_render = true unless response.nil?
+          end
+        else
+          post_body = {
+            id_field => id,
+            :format => :table
+          }
+          response = post rest_url("#{type}/task_status"), post_body
+          response.print_error_table = true
+          response.render_table(:task_status)
+        end
+      end
+
+      def list_task_info_aux(type, id)
+        id_sym = "#{type}_id".to_sym
+        post_body = {
+          id_sym => id,
+          :format => :list
+        }
+        response = post rest_url("#{type}/task_status"), post_body
+        
+        raise DTK::Client::DtkError, "[SERVER ERROR] #{response['errors'].first['message']}." if response["status"].eql?('notok')
+           
+        response.override_command_class("list_task")
+        puts response.render_data
+      end
+    end
+
+end

data/lib/commands/thor/account.rb

@@ -0,0 +1,213 @@
+dtk_require_from_base('command_helpers/ssh_processing')
+dtk_require_from_base("dtk_logger")
+dtk_require_from_base("util/os_util")
+dtk_require_from_base('configurator')
+
+module DTK::Client
+  class Account < CommandBaseThor
+    include ParseFile
+
+    KEY_EXISTS_ALREADY_CONTENT = 'key exists already'
+
+    no_tasks do
+      def password_prompt(message, add_options=true)        
+        begin
+          while line = Readline.readline("#{message}: ", add_hist = false)
+            raise Interrupt if line.empty?
+            return line
+          end
+        rescue Interrupt => e
+          retry
+        ensure
+          puts "\n" if line.nil?
+        end
+      end
+    end
+
+    def self.internal_add_user_access(url, post_body, component_name)
+      response = post(rest_url(url),post_body)
+      key_exists_already = (response.error_message||'').include?(KEY_EXISTS_ALREADY_CONTENT)
+      puts "Key exists already for #{component_name}" if key_exists_already
+      [response, key_exists_already]
+    end
+
+    def self.add_key(path_to_key, name=nil)
+      match, matched_username = nil, nil
+    
+      unless File.file?(path_to_key)
+        OsUtil.put_warning "[ERROR]  " ,"No ssh key file found at (#{path_to_key}). Path is wrong or it is necessary to generate the public rsa key (e.g., run `ssh-keygen -t rsa`)", :red
+        abort
+      end
+
+      rsa_pub_key = File.open(path_to_key){|f|f.read}
+
+      post_body = { :rsa_pub_key => rsa_pub_key.chomp }
+            
+      post_body.merge!(:username => name.chomp) if name
+      proper_response = nil
+      response, key_exists_already = Account.internal_add_user_access("service_module/add_user_direct_access", post_body, 'service module')
+      return response unless (response.ok? || key_exists_already)
+
+
+      if response.ok?
+        proper_response = response
+        match = response.data['match']
+        matched_username = response.data['matched_username']
+      end
+
+      response, key_exists_already = Account.internal_add_user_access("component_module/add_user_direct_access", post_body, 'component module')
+      return response unless (response.ok? || key_exists_already)
+      proper_response = response if response.ok?
+      
+      # if either of request passed we will add to known hosts
+      if match
+        OsUtil.print("Provided RSA public key already exists, user creation aborted!", :yellow) 
+      elsif proper_response
+        repo_manager_fingerprint,repo_manager_dns = proper_response.data_ret_and_remove!(:repo_manager_fingerprint,:repo_manager_dns)
+        SshProcessing.update_ssh_known_hosts(repo_manager_dns,repo_manager_fingerprint)
+        OsUtil.print("Ssh key added successfully!", :yellow)
+
+        return proper_response
+      else
+        nil
+      end
+    end
+
+    desc "set-password", "Change password for your dtk user account"
+    def set_password(context_params)
+      old_pass_prompt, old_pass, new_pass_prompt, confirm_pass_prompt = nil
+      cred_file = ::DTK::Client::Configurator.CRED_FILE
+      old_pass = parse_key_value_file(cred_file)[:password]
+      username = parse_key_value_file(cred_file)[:username]
+
+      if old_pass.nil?
+        OsUtil.print("Unable to retrieve your current password!", :yellow)
+        return
+      end
+
+      3.times do
+        old_pass_prompt = password_prompt("Enter old password")
+
+        break if (old_pass.eql?(old_pass_prompt) || old_pass_prompt.nil?)
+        OsUtil.print("Incorrect old password!", :yellow)
+      end
+      return unless old_pass.eql?(old_pass_prompt)
+
+      new_pass_prompt = password_prompt("Enter new password")
+      return if new_pass_prompt.nil?
+      confirm_pass_prompt = password_prompt("Confirm new password")
+      
+      if new_pass_prompt.eql?(confirm_pass_prompt)
+        post_body = {:new_password => new_pass_prompt}
+        response = post rest_url("account/set_password"), post_body
+        return response unless response.ok?
+
+        ::DTK::Client::Configurator.regenerate_conf_file(cred_file, [['username', "#{username.to_s}"], ['password', "#{new_pass_prompt.to_s}"]], '')
+        OsUtil.print("Password changed successfully!", :yellow)
+      else
+        OsUtil.print("Entered passwords don't match!", :yellow)
+        return
+      end
+    end
+
+    desc "list-ssh-keys", "Show list of keys that your account profile has saved"
+    def list_ssh_keys(context_params)
+      username  = parse_key_value_file(::DTK::Client::Configurator.CRED_FILE)[:username]
+      post_body = {:username => username}
+
+      response = post rest_url("account/list_ssh_keys"), post_body
+      response.render_table(:account_ssh_keys)
+    end
+
+    desc "add-ssh-key NAME [PATH-TO-RSA-PUB-KEY]","Adds direct access to modules. Optional parameters is path to a ssh rsa public key and default is <user-home-dir>/.ssh/id_rsa.pub"
+    def add_ssh_key(context_params)
+      name, path_to_key = context_params.retrieve_arguments([:option_1!, :option_2],method_argument_names)
+      path_to_key ||= SshProcessing.default_rsa_pub_key_path()
+      access_granted = Account.add_key(path_to_key, name)
+
+      FileUtils.touch(DTK::Client::Configurator::DIRECT_ACCESS) if access_granted
+    end
+
+    desc "remove-ssh-key NAME ","Removes user and direct access to modules."
+    def remove_ssh_key(context_params)
+      name = context_params.retrieve_arguments([:option_1!],method_argument_names)
+      post_body = {:username => name.chomp}
+
+      response = post rest_url("component_module/remove_user_direct_access"), post_body
+      return response unless response.ok?
+
+      response = post rest_url("service_module/remove_user_direct_access"), post_body
+      return response unless response.ok?
+
+      OsUtil.print("Ssh key removed successfully!", :yellow)
+    end
+
+
+
+    # Will leave this commented for now until we check if above commands work as expected
+    #
+    # def self.add_access(path_to_key)
+    #   unless File.file?(path_to_key)
+    #     raise DTK::Client::DtkError,"No ssh key file found at (#{path_to_key}). Path is wrong or it is necessary to generate the public rsa key (e.g., run ssh-keygen -t rsa)"
+    #   end
+    #   rsa_pub_key = File.open(path_to_key){|f|f.read}
+    #   post_body = {
+    #     :rsa_pub_key => rsa_pub_key.chomp
+    #   }
+
+    #   proper_response = nil
+
+    #   response, key_exists_already = Account.internal_add_user_access("service_module/add_user_direct_access", post_body, 'service module')
+    #   return response unless (response.ok? || key_exists_already)
+    #   proper_response = response if response.ok?
+
+    #   response, key_exists_already = Account.internal_add_user_access("component_module/add_user_direct_access", post_body, 'component module')
+    #   return response unless (response.ok? || key_exists_already)
+    #   proper_response = response if response.ok?
+      
+    #   # if either of request passed we will add to known hosts
+    #   if proper_response
+    #     repo_manager_fingerprint,repo_manager_dns = proper_response.data_ret_and_remove!(:repo_manager_fingerprint,:repo_manager_dns)
+    #     SshProcessing.update_ssh_known_hosts(repo_manager_dns,repo_manager_fingerprint)
+    #     return proper_response
+    #   else
+    #     nil
+    #   end
+    # end
+
+    # desc "add-direct-access [PATH-TO-RSA-PUB-KEY]","Adds direct access to modules. Optional parameters is path to a ssh rsa public key and default is <user-home-dir>/.ssh/id_rsa.pub"
+    # def add_direct_access(context_params)
+    #   return
+    #   path_to_key = context_params.retrieve_arguments([:option_1],method_argument_names)
+    #   path_to_key ||= SshProcessing.default_rsa_pub_key_path()
+    #   access_granted = Account.add_access(path_to_key)
+
+    #   FileUtils.touch(DTK::Client::Configurator::DIRECT_ACCESS) if access_granted
+    #   access_granted
+    # end
+
+    # desc "remove-direct-access [PATH-TO-RSA-PUB-KEY]","Removes direct access to modules. Optional paramaeters is path to a ssh rsa public key and default is <user-home-dir>/.ssh/id_rsa.pub"
+    # def remove_direct_access(context_params)
+    #   path_to_key = context_params.retrieve_arguments([:option_1],method_argument_names)
+    #   path_to_key ||= SshProcessing.default_rsa_pub_key_path()
+
+    #   # path_to_key ||= "#{ENV['HOME']}/.ssh/id_rsa.pub" #TODO: very brittle
+    #   unless File.file?(path_to_key)
+    #     raise DTK::Client::DtkError,"No File found at (#{path_to_key}). Path is wrong or it is necessary to generate the public rsa key (e.g., run ssh-keygen -t rsa)"
+    #   end
+    #   rsa_pub_key = File.open(path_to_key){|f|f.read}
+    #   post_body = {
+    #     :rsa_pub_key => rsa_pub_key.chomp
+    #   }
+    #   response = post rest_url("component_module/remove_user_direct_access"), post_body
+    #   return response unless response.ok?
+
+    #   response = post rest_url("service_module/remove_user_direct_access"), post_body
+    #   return response unless response.ok?
+
+    #   FileUtils.rm(DTK::Client::Configurator::DIRECT_ACCESS) if File.exists?(DTK::Client::Configurator::DIRECT_ACCESS)
+    #   return response
+    # end
+
+  end
+end

data/lib/commands/thor/assembly.rb

@@ -0,0 +1,329 @@
+dtk_require("../../shell/status_monitor")
+
+module DTK::Client
+  class Assembly < CommandBaseThor
+    no_tasks do
+      def get_assembly_name(assembly_id)
+        name = nil
+        3.times do
+          name = get_name_from_id_helper(assembly_id)
+          break if name
+        end
+
+        name
+      end
+
+      def get_assembly_stage_name(assembly_list,assembly_template_name)
+        name = nil
+        current_list = assembly_list.select{|e| e.include?(assembly_template_name)}
+
+        if current_list.empty?
+          name = assembly_template_name
+        else
+          numbers = []
+          base_name = nil
+
+          assembly_list.each do |assembly|
+            match = assembly.match(/#{assembly_template_name}(-)(\d*)/)
+            base_name = assembly_template_name if assembly_template_name.include?(assembly)
+            numbers << match[2].to_i if match
+          end
+
+          unless base_name
+            name = assembly_template_name
+          else
+            highest = numbers.max||1
+            new_highest = highest+1
+
+            all = (2..new_highest).to_a
+            nums = all - numbers
+            name = assembly_template_name + "-#{nums.first}"
+          end
+        end
+
+        name
+      end
+    end
+
+    def self.whoami()
+      return :assembly, "assembly/list", {:subtype  => 'template'}
+    end
+
+    def self.get_assembly_template_id_for_service(assembly_template_name, service)
+      assembly_template_id = nil
+      # TODO: See with Rich if there is better way to resolve this
+      response = DTK::Client::CommandBaseThor.get_cached_response(:assembly, "assembly/list", {:subtype => 'template' })
+      # response = DTK::Client::CommandBaseThor.get_cached_response(:module, "service_module/list")
+
+      if response.ok?
+        unless response['data'].nil?
+          response['data'].each do |module_item|
+            if ("#{service.to_s}::#{assembly_template_name.to_s}" == (module_item['display_name']))
+              assembly_template_id = module_item['id']
+              break
+            end
+          end
+        end
+      end
+
+      raise DTK::Client::DtkError, "Illegal name (#{assembly_template_name}) for assembly." if assembly_template_id.nil?
+      
+      return assembly_template_id
+    end
+
+    def self.get_assembly_template_name_for_service(assembly_template_id, service)
+      assembly_template_name = nil
+      # TODO: See with Rich if there is better way to resolve this
+      response = DTK::Client::CommandBaseThor.get_cached_response(:assembly, "assembly/list", {:subtype => 'template' })
+
+      if response.ok?
+        unless response['data'].nil?
+          response['data'].each do |module_item|
+            if assembly_template_id.to_i == module_item['id']
+              assembly_template_name = module_item['display_name'].gsub("#{service.to_s}::",'')
+              break
+            end
+          end
+        end
+      end
+
+      raise DTK::Client::DtkError, "Illegal name (#{assembly_template_name}) for assembly." if assembly_template_name.nil?
+      return assembly_template_name
+    end
+
+    def self.pretty_print_cols()
+      PPColumns.get(:assembly)
+    end
+
+
+    # List assembly templates for specific module
+    def self.validation_list(context_params)
+      if context_params.is_there_identifier?(:"service-module")
+        service_module_id = context_params.retrieve_arguments([:service_module_id!])
+        get_cached_response(:assembly, "service_module/list_assemblies", { :service_module_id => service_module_id })
+      else
+        get_cached_response(:assembly, "assembly/list", {:subtype => 'template' })
+      end
+    end
+
+    def self.assembly_list()
+      assembly_list = []
+      response = get_cached_response(:service, "assembly/list", {})
+      raise DTK::Client::DtkError, "Unable to retreive service list." unless (response.nil? || response.ok?)
+      
+      if assemblies = response.data
+        assemblies.each do |assembly|
+          assembly_list << assembly["display_name"]
+        end
+      end
+      
+      assembly_list
+    end
+
+    desc "ASSEMBLY-NAME/ID info", "Get information about given assembly."
+    method_option :list, :type => :boolean, :default => false
+    def info(context_params)
+      assembly_template_id = context_params.retrieve_arguments([:assembly_id!],method_argument_names)
+      data_type = :assembly_template
+      
+      post_body = {
+        :assembly_id => assembly_template_id,
+        :subtype => 'template',
+      }
+      
+      post rest_url("assembly/info"), post_body
+    end
+
+    desc "ASSEMBLY-NAME/ID list-nodes [--service SERVICE-NAME]", "List all nodes for given assembly."
+    method_option :list, :type => :boolean, :default => false
+    method_option "service",:aliases => "-s" ,
+      :type => :string, 
+      :banner => "SERVICE-LIST-FILTER",
+      :desc => "Service list filter"
+    def list_nodes(context_params)
+      context_params.method_arguments = ["nodes"]
+      list(context_params)
+    end
+
+    desc "ASSEMBLY-NAME/ID list-components [--service SERVICE-NAME]", "List all components for given assembly."
+    method_option :list, :type => :boolean, :default => false
+    method_option "service",:aliases => "-s" ,
+      :type => :string, 
+      :banner => "SERVICE-LIST-FILTER",
+      :desc => "Service list filter"
+    def list_components(context_params)
+      context_params.method_arguments = ["components"]
+      list(context_params)
+    end
+
+#    desc "[ASSEMBLY-TEMPLATE-NAME/ID] show [nodes|components|targets]", "List all nodes/components/targets for given assembly template."
+    #TODO: temporaily taking out target option
+    desc "list", "List all assemblies."
+    def list(context_params)
+      assembly_template_id, about, service_filter = context_params.retrieve_arguments([:assembly_id, :option_1, :option_1],method_argument_names)
+
+      if assembly_template_id.nil?
+
+        if options.service
+          service_id = options.service
+          context_params_for_service = DTK::Shell::ContextParams.new
+          context_params_for_service.add_context_to_params("service_module", "service_module", service_id)
+          context_params_for_service.method_arguments = ['assembly',"#{service_id}"]
+          
+          response = DTK::Client::ContextRouter.routeTask("service_module", "list", context_params_for_service, @conn)
+        else
+          response = post rest_url("assembly/list"), {:subtype => 'template', :detail_level => 'nodes'}
+          data_type = :assembly_template
+          response.render_table(data_type) unless options.list?
+          return response
+        end
+
+      else
+        
+        post_body = {
+          :subtype => 'template',
+          :assembly_id => assembly_template_id,
+          :about => about
+        }
+
+        case about
+        when 'nodes'
+          response = post rest_url("assembly/info_about"), post_body
+          data_type = :node_template
+        when 'components'
+          response = post rest_url("assembly/info_about"), post_body
+          data_type = :component
+        # when 'attributes'
+          # response = post rest_url("assembly/info_about"), post_body
+          # data_type = :attribute
+        else
+          raise_validation_error_method_usage('list')
+        end
+
+        response.render_table(data_type) unless options.list?
+
+        return response
+      end
+    end
+
+    desc "ASSEMBLY-NAME/ID stage [INSTANCE-NAME] [-t TARGET-NAME/ID]", "Stage assembly in target."
+    method_option "in-target",:aliases => "-t" ,
+      :type => :string, 
+      :banner => "TARGET-NAME/ID",
+      :desc => "Target (id) to create assembly in" 
+    def stage(context_params)
+      assembly_template_id, name = context_params.retrieve_arguments([:assembly_id!, :option_1],method_argument_names)
+      post_body = {
+        :assembly_id => assembly_template_id
+      }
+
+      assembly_template_name = get_assembly_name(assembly_template_id)
+      assembly_template_name.gsub!('::','-') if assembly_template_name
+
+      # we check current options and forwarded options (from deploy method)
+      in_target = options["in-target"] || context_params.get_forwarded_thor_option("in-target")
+      assembly_list = Assembly.assembly_list()
+
+      if name
+        raise DTK::Client::DtkValidationError, "Unable to stage service with name '#{name}'. Service with specified name exists already!" if assembly_list.include?(name)
+      else
+        name = get_assembly_stage_name(assembly_list,assembly_template_name)
+      end
+      
+      post_body.merge!(:target_id => in_target) if in_target
+      post_body.merge!(:name => name) if name
+
+      response = post rest_url("assembly/stage"), post_body
+      return response unless response.ok?
+      # when changing context send request for getting latest assemblies instead of getting from cache
+      @@invalidate_map << :service
+      @@invalidate_map << :assembly
+
+      return response
+    end
+
+    # desc "ASSEMBLY-NAME/ID deploy [-v VERSION] [INSTANCE-NAME] [-t TARGET-NAME/ID] [-m COMMIT-MSG]", "Stage and deploy assembly in target."
+    # version_method_option
+    desc "ASSEMBLY-NAME/ID deploy [INSTANCE-NAME] [-t TARGET-NAME/ID] [-m COMMIT-MSG]", "Stage and deploy assembly in target."
+    method_option "in-target",:aliases => "-t" ,
+      :type => :string,
+      :banner => "TARGET-NAME/ID",
+      :desc => "Target (id) to create assembly in" 
+    method_option "commit_msg",:aliases => "-m" ,
+      :type => :string, 
+      :banner => "COMMIT-MSG",
+      :desc => "Commit message"
+    def deploy(context_params)
+      context_params.forward_options(options)
+      response = stage(context_params)
+
+      return response unless response.ok?
+
+      # create task      
+      # commented assemlby_id until we implement json to yaml parsing on client side instead of server side
+      # assembly_id = response.data(:assembly_id)
+
+      # temp solution just to make deploy to work, since response we get from 'stage' command is simple string presented as yaml
+      assembly_id = response.data.match(/(id:)\s*(\d+)/)[2]
+
+      post_body = {
+        :assembly_id => assembly_id,
+        :commit_msg => options["commit_msg"]||"Initial deploy"
+      }
+
+      response = post rest_url("assembly/find_violations"), post_body
+      return response unless response.ok?
+      if response.data and response.data.size > 0
+        error_message =  "The following violations were found; they must be corrected before the assembly can be deployed"
+        DTK::Client::OsUtil.print(error_message, :red)
+        return response.render_table(:violation)
+      end
+
+      ret = response = post(rest_url("assembly/create_task"), post_body)        
+
+      return response unless response.ok?
+
+      # execute task
+      task_id = response.data(:task_id)
+      response = post(rest_url("task/execute"), "task_id" => task_id)
+
+      # start watching task ID
+      if $shell_mode
+        DTK::Shell::StatusMonitor.start_monitoring(task_id) if response.ok?
+      end
+
+      return response unless response.ok?
+      ret.add_data_value!(:task_id,task_id)
+
+      # when changing context send request for getting latest assemblies instead of getting from cache
+      @@invalidate_map << :service
+
+      return ret
+    end
+
+
+    desc "delete ASSEMBLY-ID", "Delete assembly"
+    method_option :force, :aliases => '-y', :type => :boolean, :default => false
+    def delete(context_params)
+      assembly_template_id = context_params.retrieve_arguments([:option_1!],method_argument_names)
+      unless options.force?
+        # Ask user if really want to delete assembly-template, if not then return to dtk-shell without deleting
+        return unless Console.confirmation_prompt("Are you sure you want to delete assembly '#{assembly_template_id}'"+"?")
+      end
+
+      post_body = {
+        :assembly_id => assembly_template_id,
+        :subtype => :template
+      }
+      response = post rest_url("assembly/delete"), post_body
+      
+      # when changing context send request for getting latest assemblies instead of getting from cache
+      @@invalidate_map << :assembly
+      return response unless response.ok?
+      module_name,branch = response.data(:module_name,:workspace_branch)
+      response = Helper(:git_repo).pull_changes?(:service_module,module_name,:local_branch => branch)
+      return response unless response.ok?()
+      Response::Ok.new()
+    end
+  end
+end

data/lib/commands/thor/attribute.rb

@@ -0,0 +1,62 @@
+
+module DTK::Client
+  class Attribute < CommandBaseThor
+
+    no_tasks do
+
+      def self.assembly_validation_list(context_params)
+        assembly_or_worspace_id, node_id, component_id = context_params.retrieve_arguments([[:service_id!, :workspace_id!], :node_id!, :component_id!])
+
+        post_body = {
+          :assembly_id  => assembly_or_worspace_id,
+          :node_id      => node_id,
+          :component_id => component_id,
+          :subtype      => 'instance',
+          :about        => 'attributes',
+          :filter       => nil
+        }
+
+        response = get_cached_response(:service_node_component_attribute, "assembly/info_about", post_body)
+        modified_response = response.clone_me()
+
+        modified_response['data'].each { |e| e['display_name'] = e['display_name'].split('/').last }
+          
+        return modified_response
+      end
+
+      def self.module_validation_list(context_params)
+        component_module_id = context_params.retrieve_arguments([:module_id!])
+
+        post_body = {
+          :component_module_id => component_module_id,
+          :about => :attributes
+        }
+        response = post rest_url("component_module/info_about"), post_body
+           
+        modified_response = response.clone_me()
+        modified_response['data'].each { |e| e['display_name'] = e['display_name'].split('/').last }
+        #modified_response['data'].each { |e| e['display_name'] = e['display_name'].match(/.+\[.+::(.*)\]/)[1] }
+        
+        return modified_response
+      end
+
+    end
+
+    def self.validation_list(context_params)
+      command_name = context_params.root_command_name
+
+      case command_name
+      when 'service'
+        return assembly_validation_list(context_params)
+      when 'workspace'
+        return assembly_validation_list(context_params)
+      when 'module'
+        return module_validation_list(context_params)
+      else
+        raise DTK::Client::DtkError,"Attribute 'validation_list' not supported for #{command_name}, implementation nedeed."
+      end
+    end
+
+
+  end
+end