dtk-client 0.7.4.1 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a7875186712bb106f9fbbf11458c702e66041ae
-  data.tar.gz: 23996874f5fb73b451fab137e6157252addb9224
+  metadata.gz: 90044fb0aeac2ab716a8bbad16eab81ba09b177f
+  data.tar.gz: af29727daadaa126bc8b3ea39e8515b49e8ace37
 SHA512:
-  metadata.gz: 6b938efca3539c8ba284580cfc4f747c179e45939abe5025f479c696fa227618c4c98731e8b493f77834ed396c31b63f81230b3e324b8618be907da363efd3ea
-  data.tar.gz: f428e0857dbea981c780d12bc8e4fb7cf31d2a249282302d29d358917364a52230426c9dcf6802e85289b9859c7cf15f223b194a7a7a6dbb2a21b2aacf0292f8
+  metadata.gz: 4d40f5739a3921835fb2c38cad3428134f807091327c50eb40c7066cc1fa8168dc1e8c60da2e26fd9c7ceb6c6940f6d81e74001717a6bd0c0f5335bb3abbf7ae
+  data.tar.gz: e2ab0c0121f8034da2262595f5f7caabe81d6cd85a37a72b7fe6983d480ea89503779e8bb2aef0e5efc4d8d512d8088929db0ec4f634a33a920444e0f2c77326

data/bin/dtk

@@ -15,9 +15,11 @@ require File.expand_path('../lib/shell/domain/shadow_entity', File.dirname(__FIL
 require File.expand_path('../lib/commands/thor/account', File.dirname(__FILE__))
 require File.expand_path('../lib/shell/parse_monkey_patch', File.dirname(__FILE__))
 require File.expand_path('../lib/shell/help_monkey_patch', File.dirname(__FILE__))
+require File.expand_path('../lib/execute/cli_pure/cli_rerouter', File.dirname(__FILE__))
 
 
 require 'shellwords'
+require 'json'
 
 $: << "/usr/lib/ruby/1.8/" #TODO: put in to get around path problem in rvm 1.9.2 environment
 
@@ -47,9 +49,14 @@ end
 context = DTK::Shell::Context.new(true)
 
 begin
-  entity_name, method_name, context_params, thor_options = context.get_dtk_command_parameters(entity_name, args)
-
-  top_level_execute(entity_name, method_name, context_params, thor_options, false)
+  if ::DTK::CLIRerouter.is_candidate?(entity_name, args)
+    response_obj = ::DTK::CLIRerouter.new(entity_name, args).run()
+    puts response_obj.to_json
+  else
+    # default execution
+    entity_name, method_name, context_params, thor_options = context.get_dtk_command_parameters(entity_name, args)
+    top_level_execute(entity_name, method_name, context_params, thor_options, false)
+  end
 rescue DTK::Client::DtkError => e
   DtkLogger.instance.error(e.message, true)
 rescue Exception => e

data/bin/dtk-shell

@@ -11,4 +11,4 @@ config_exists = ::DTK::Client::Configurator.check_config_exists
 # check if .add_direct_access file exists, if not then add direct access and create .add_direct_access file
 resolve_direct_access(::DTK::Client::Configurator.check_direct_access, config_exists)
 
-run_shell_command()
+run_shell_command()

data/lib/command_helpers/git_repo.rb

@@ -118,6 +118,7 @@ module DTK; module Client; class CommandHelper
         full_module_name = full_module_name(module_name,opts)
         repo_dir = local_repo_dir(type,full_module_name,opts[:version],opts)
         repo = create(repo_dir,opts[:local_branch])
+        opts.merge!(:full_module_name => full_module_name)
         response = pull_repo_changes_aux(repo,opts)
         response
       end
@@ -446,46 +447,51 @@ module DTK; module Client; class CommandHelper
       { "diffs" => (diffs[:diffs]||"").to_s, "status" => repo.local_summary() }
     end
 
-    def pull_repo_changes_aux(repo,opts={})
+    def pull_repo_changes_aux(repo, opts = {})
       diffs = DiffSummary.new()
       hard_reset = opts[:hard_reset] || opts[:force]
 
       # default commit in case it is needed
-      repo.stage_and_commit("Commit prior to pull from remote") if repo.changed?
+      repo.stage_and_commit('Commit prior to pull from remote') if repo.changed?
 
       if commit_sha = opts[:commit_sha]
-        #no op if at commit_sha
+        # no op if at commit_sha
         return diffs if (commit_sha == repo.head_commit_sha()) && !hard_reset
       end
 
-      if opts[:remote_repo] and opts[:remote_repo_url]
-        repo.add_remote(opts[:remote_repo],opts[:remote_repo_url])
+      if opts[:remote_repo] && opts[:remote_repo_url]
+        repo.add_remote(opts[:remote_repo], opts[:remote_repo_url])
       end
 
       repo.fetch(remote(opts[:remote_repo]))
       local_branch = repo.local_branch_name
-      remote_branch_ref = remote_branch_ref(local_branch,opts)
+      remote_branch_ref = remote_branch_ref(local_branch, opts)
 
       if hard_reset
-        diffs = DiffSummary.diff(repo,local_branch, remote_branch_ref)
+        diffs = DiffSummary.diff(repo, local_branch, remote_branch_ref)
         repo.merge_theirs(remote_branch_ref)
-        return({:diffs => diffs, :commit_sha => repo.head_commit_sha()})
+        return({ :diffs => diffs, :commit_sha => repo.head_commit_sha() })
       end
 
-      #check if merge needed
-      merge_rel = repo.merge_relationship(:remote_branch,remote_branch_ref)
+      # check if merge needed
+      merge_rel = repo.merge_relationship(:remote_branch, remote_branch_ref)
       if merge_rel == :equal
         { :diffs => diffs, :commit_sha => repo.head_commit_sha() }
-      elsif [:branchpoint,:local_ahead].include?(merge_rel)
-        raise ErrorUsage.new("Unable to do fast-forward merge. You can use --force but all changes in the service instance will be lost") unless opts[:force]
-        # TODO: right now just wiping out what is in repo
-        diffs = DiffSummary.diff(repo,local_branch, remote_branch_ref)
-        repo.merge_theirs(remote_branch_ref)
-        { :diffs => diffs, :commit_sha => repo.head_commit_sha() }
+      elsif [:branchpoint, :local_ahead].include?(merge_rel)
+        if opts[:force]
+          # TODO: right now just wiping out what is in repo
+          diffs = DiffSummary.diff(repo, local_branch, remote_branch_ref)
+          repo.merge_theirs(remote_branch_ref)
+          { :diffs => diffs, :commit_sha => repo.head_commit_sha() }
+        elsif opts[:ignore_dependency_merge_conflict]
+          { :diffs => diffs, :commit_sha => repo.head_commit_sha(), :custom_message => "Unable to do fast-forward merge. You can go to '#{opts[:full_module_name]}' and pull with --force option but all changes will be lost." }
+        else
+          raise Error.new('Unable to do fast-forward merge. You can use --force but all changes will be lost.')
+        end
       elsif merge_rel == :local_behind
-        #see if any diffs between fetched remote and local branch
-        #this has be done after commit
-        diffs = DiffSummary.diff(repo,local_branch, remote_branch_ref)
+        # see if any diffs between fetched remote and local branch
+        # this has be done after commit
+        diffs = DiffSummary.diff(repo, local_branch, remote_branch_ref)
         return diffs unless diffs.any_diffs?()
 
         begin
@@ -494,7 +500,7 @@ module DTK; module Client; class CommandHelper
           puts e
         end
 
-        if commit_sha and commit_sha != repo.head_commit_sha()
+        if commit_sha && commit_sha != repo.head_commit_sha()
           raise Error.new("Git synchronization problem: expected local head to have sha (#{commit_sha})")
         end
 

data/lib/command_helpers/jenkins_client.rb

@@ -1,4 +1,5 @@
-require 'jenkins-client' 
+# TODO: Marked for removal [Haris] - Do we need this?
+require 'jenkins-client'
 module DTK; module Client
   class JenkinsClient
     require File.expand_path('jenkins_client/config_xml', File.dirname(__FILE__))
@@ -58,7 +59,7 @@ module DTK; module Client
       def create_job(job_name,config_xml_contents)
         ::Jenkins::Client::Job.create(job_name, config_xml_contents)
       end
-    
+
       def get_info()
         get('api/json')
       end
@@ -86,6 +87,6 @@ module DTK; module Client
     end
   end
 end; end
- 
+
 
 

data/lib/command_helpers/service_importer.rb

@@ -18,10 +18,10 @@ module DTK::Client
     ##
     # Method will trigger pull from dtkn for each existing module
     #
-    def trigger_module_auto_pull(required_modules, force = false)
+    def trigger_module_auto_pull(required_modules, opts = {})
       return if required_modules.empty?
 
-      if force || Console.confirmation_prompt("Do you want to update in addition to this module its dependent modules from the catalog?")
+      if opts[:force] || Console.confirmation_prompt("Do you want to update in addition to this module its dependent modules from the catalog?")
         required_modules.each do |r_module|
           module_name = full_module_name(r_module)
           module_type = r_module['type']
@@ -31,46 +31,56 @@ module DTK::Client
           new_context_params = DTK::Shell::ContextParams.new
           new_context_params.add_context_to_params(module_type, module_type)
           new_context_params.add_context_name_to_params(module_type, module_type, module_name)
-          new_context_params.forward_options( { :skip_recursive_pull => true })
+
+          forwarded_opts = { skip_recursive_pull: true, ignore_dependency_merge_conflict: true }
+          forwarded_opts.merge!(:do_not_raise => true) if opts[:do_not_raise]
+          new_context_params.forward_options(forwarded_opts)
 
           response = ContextRouter.routeTask(module_type, "pull_dtkn", new_context_params, @conn)
 
-          raise DTK::Client::DtkError, response.error_message unless response.ok?
+          unless response.ok?
+            if opts[:do_not_raise]
+              OsUtil.print("#{response.error_message}", :red)
+            else
+              raise DTK::Client::DtkError, response.error_message
+            end
+          end
         end
 
-        print "Resuming pull ... " unless force
+        print "Resuming pull ... " unless opts[:force]
       end
     end
 
-
     ##
     # Method will trigger import for each missing module component
     #
-    def trigger_module_auto_import(modules_to_import, required_modules, opts={})
-      puts "Auto-importing missing module(s)"
-      update_all, update_none = false, false
+    def trigger_module_auto_import(modules_to_import, required_modules, opts = {})
+      puts 'Auto-installing missing module(s)'
+      update_all  = false
+      update_none = false
 
       # Print out or update installed modules from catalog
       required_modules.each do |r_module|
         module_name = full_module_name(r_module)
         module_type = r_module['type']
 
-        print "Using #{module_type.gsub('_',' ')} '#{module_name}'\n"
+        print "Using #{module_type.gsub('_', ' ')} '#{module_name}'\n"
         next if update_none || opts[:update_none]
 
         if update_all
-          trigger_module_auto_pull([r_module], true)
+          trigger_module_auto_pull([r_module], :force => true, :do_not_raise => true)
         else
-          update = Console.confirmation_prompt_additional_options("Do you want to update dependent #{module_type.gsub('_',' ')} '#{module_name}' from the catalog?", ['all', 'none'])
+          options = required_modules.size > 1 ? %w(all none) : []
+          update  = Console.confirmation_prompt_additional_options("Do you want to update dependent #{module_type.gsub('_', ' ')} '#{module_name}' from the catalog?", options)
           next unless update
 
           if update.to_s.eql?('all')
             update_all = true
-            trigger_module_auto_pull([r_module], true)
+            trigger_module_auto_pull([r_module], :force => true, :do_not_raise => true)
           elsif update.to_s.eql?('none')
             update_none = true
           else
-            trigger_module_auto_pull([r_module], true)
+            trigger_module_auto_pull([r_module], :force => true, :do_not_raise => true)
           end
         end
       end
@@ -84,25 +94,27 @@ module DTK::Client
         module_url  = m_module['module_url']
 
         # descriptive message
-        import_msg  = "Importing #{module_type.gsub('_',' ')} '#{module_name}'"
+        importing  = module_url ? "Importing" : "Installing"
+        import_msg = "#{importing} #{module_type.gsub('_', ' ')} '#{module_name}'"
         import_msg += " from git source #{module_url}" if module_url
         print "#{import_msg} ... "
 
-        unless module_url
+        if module_url
+          # import from Git source
+          new_context_params = ::DTK::Shell::ContextParams.new([module_url, module_name])
+          new_context_params.forward_options(:internal_trigger => true)
+          response = ContextRouter.routeTask(module_type, 'import_git', new_context_params, @conn)
+        else
           # import from Repo Manager
           new_context_params = ::DTK::Shell::ContextParams.new([module_name])
           new_context_params.override_method_argument!('option_2', m_module['version'])
-          new_context_params.forward_options( { :skip_cloning => false, :skip_auto_install => true, :module_type => module_type}).merge!(opts)
-          response = ContextRouter.routeTask(module_type, "install", new_context_params, @conn)
-        else
-          # import from Git source
-          new_context_params = ::DTK::Shell::ContextParams.new([module_url, module_name])
-          new_context_params.forward_options( { :internal_trigger => true })
-          response = ContextRouter.routeTask(module_type, "import_git", new_context_params, @conn)
+          new_context_params.forward_options(:skip_cloning => false, :skip_auto_install => true, :module_type => module_type).merge!(opts)
+          response = ContextRouter.routeTask(module_type, 'install', new_context_params, @conn)
         end
 
-        puts(response.data(:does_not_exist) ? response.data(:does_not_exist) : "Done.")
-        raise DTK::Client::DtkError, response.error_message unless response.ok?
+        ignore_component_error = (new_context_params.get_forwarded_options() || {})[:ignore_component_error] && module_type.eql?('component_module')
+        puts(response.data(:does_not_exist) ? response.data(:does_not_exist) : 'Done.')
+        raise DTK::Client::DtkError, response.error_message if !response.ok? && !ignore_component_error
       end
 
       Response::Ok.new()

data/lib/commands.rb

@@ -25,7 +25,7 @@ module DTK
         DTK::Client::Session.get_connection()
       end
 
-      def self.handle_argument_error(task, error) 
+      def self.handle_argument_error(task, error)
         super
       end
 
@@ -35,6 +35,6 @@ module DTK
         self.class.pretty_print_cols()
       end
     end
-  
+
   end
 end

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

@@ -56,8 +56,10 @@ module DTK::Client
 
     # mode will be :create or :update
     # service_module_name_x can be name or fullname (NS:MOduleName)
-    def promote_assembly_aux(mode,assembly_or_workspace_id,service_module_name_x=nil,assembly_template_name=nil,opts={})
-      namespace,local_clone_dir_exists = nil, nil
+    def promote_assembly_aux(mode, assembly_or_workspace_id, service_module_name_x = nil, assembly_template_name = nil, opts = {})
+      namespace = nil
+      local_clone_dir_exists = nil
+
       post_body = {
         :assembly_id => assembly_or_workspace_id,
         :mode => mode.to_s
@@ -66,7 +68,7 @@ module DTK::Client
       if service_module_name_x
         service_module_name = service_module_name_x
         if service_module_name_x =~ /(^[^:]+):([^:]+$)/
-          namespace,service_module_name = [$1,$2]
+          namespace, service_module_name = [$1,$2]
         end
         post_body.merge!(:service_module_name => service_module_name)
       end
@@ -81,16 +83,16 @@ module DTK::Client
       post_body.merge!(:assembly_template_name => assembly_template_name) if assembly_template_name
       post_body.merge!(:use_module_namespace => true) if opts[:use_module_namespace]
       post_body.merge!(:description => opts[:description]) if opts[:description]
-      response = post rest_url("assembly/promote_to_template"), post_body
+      response = post rest_url('assembly/promote_to_template'), post_body
       return response unless response.ok?()
 
-      #synchronize_clone will load new assembly template into service clone on workspace (if it exists)
-      commit_sha,workspace_branch,namespace,full_module_name,repo_url,version = response.data(:commit_sha,:workspace_branch,:module_namespace,:full_module_name,:repo_url,:version)
+      # synchronize_clone will load new assembly template into service clone on workspace (if it exists)
+      commit_sha, workspace_branch, namespace, full_module_name, repo_url, version = response.data(:commit_sha, :workspace_branch, :module_namespace, :full_module_name, :repo_url, :version)
       service_module_name ||= response.data(:module_name)
-      opts = {:local_branch=>workspace_branch, :namespace => namespace}
+      opts = { :local_branch => workspace_branch, :namespace => namespace }
 
       if (mode == :update) || local_clone_dir_exists
-        response = Helper(:git_repo).synchronize_clone(:service_module,service_module_name,commit_sha,opts)
+        response = Helper(:git_repo).synchronize_clone(:service_module, service_module_name, commit_sha, opts)
       else
         response = Helper(:git_repo).create_clone_with_branch(:service_module, service_module_name, repo_url, workspace_branch, version, namespace)
       end
@@ -111,44 +113,63 @@ module DTK::Client
       response = post rest_url("assembly/print_includes"),:assembly_id => assembly_or_workspace_id
     end
 
-    def converge_aux(context_params)
-      assembly_or_workspace_id,task_action,task_params_string = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1,:option_2],method_argument_names)
-      
-      task_params = nil
-      if task_params_string
-        task_params = task_params_string.split(',').inject(Hash.new) do |h,av|
-          av_split = av.split('=')
-          unless av_split.size == 2
-            raise DTK::Client::DtkValidationError, "The task parameters (#{task_params_string}) is ill-formed"
-          end
-          h.merge(av_split[0] => av_split[1])
-        end
-      end
+    def list_ad_hoc_actions_aux(context_params)
+      assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
 
       post_body = {
-        :assembly_id => assembly_or_workspace_id
+        :assembly_id  => assembly_or_workspace_id,
+        :type         => options.summary? ? :component_type : :component_instance  
+      }
+
+      response = post rest_url("assembly/ad_hoc_action_list"), post_body
+      response.render_table()
+    end
+
+   # desc "SERVICE-NAME/ID execute-action COMPONENT-INSTANCE [ACTION-NAME [ACTION-PARAMS]]"
+    def execute_ad_hoc_action_aux(context_params)
+      assembly_or_workspace_id,component_id,method_name,action_params_string = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!,:option_2,:option_3],method_argument_names)
+
+      action_params = parse_params?(action_params_string)
+
+      post_body = {
+        :assembly_id  => assembly_or_workspace_id,
+        :component_id => component_id 
       }
+      post_body.merge!(:method_name => method_name) if method_name
+      post_body.merge!(:action_params => action_params) if action_params
+
+      response = post rest_url("assembly/ad_hoc_action_execute"), post_body
+      return response unless response.ok?
+
+      task_status_stream(assembly_or_workspace_id)
+      Response::Ok.new()
+    end
+
+    def converge_aux(context_params,opts={})
+      assembly_or_workspace_id,task_action,task_params_string = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1,:option_2],method_argument_names)
 
-      response = post rest_url("assembly/find_violations"), post_body
+      task_params = parse_params?(task_params_string)
+
+      # check for violations
+      response = post rest_url("assembly/find_violations"), :assembly_id => assembly_or_workspace_id
       return response unless response.ok?
       if response.data and response.data.size > 0
-        #TODO: may not directly print here; isntead use a lower level fn
         error_message = "The following violations were found; they must be corrected before workspace can be converged"
         DTK::Client::OsUtil.print(error_message, :red)
         return response.render_table(:violation)
       end
 
-      post_body.merge!(:commit_msg => options.commit_msg) if options.commit_msg
-      post_body.merge!(:task_action => task_action) if task_action
-      post_body.merge!(:task_params => task_params) if task_params
-
+      post_body = PostBody.new(
+        :assembly_id  => assembly_or_workspace_id,
+        :commit_msg?  => options.commit_msg,
+        :task_action? => task_action,
+        :task_params? => task_params
+      )
       response = post rest_url("assembly/create_task"), post_body
       return response unless response.ok?
 
       if response.data
-        confirmation_message = response.data["confirmation_message"]
-
-        if confirmation_message
+        if confirmation_message = response.data["confirmation_message"]
           return unless Console.confirmation_prompt("Workspace service is stopped, do you want to start it"+'?')
           post_body.merge!(:start_assembly=>true)
           response = post rest_url("assembly/create_task"), post_body
@@ -158,8 +179,28 @@ module DTK::Client
 
       # execute task
       task_id = response.data(:task_id)
-      post rest_url("task/execute"), "task_id" => task_id
+      response = post rest_url("task/execute"), "task_id" => task_id
+      return response unless response.ok?
+
+      if opts[:mode] == :stream
+        task_status_stream(assembly_or_workspace_id)
+      end
+
+      Response::Ok.new()
+    end
+
+    def parse_params?(params_string)
+      if params_string
+        params_string.split(',').inject(Hash.new) do |h,av|
+          av_split = av.split('=')
+          unless av_split.size == 2
+            raise DtkValidationError, "The parameter string (#{params_string}) is ill-formed"
+          end
+          h.merge(av_split[0] => av_split[1])
+        end
+      end
     end
+    private :parse_params?
 
     def edit_module_aux(context_params)
       assembly_or_workspace_id, component_module_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!],method_argument_names)
@@ -208,15 +249,24 @@ module DTK::Client
       response = post rest_url("assembly/prepare_for_edit_module"), post_body
     end
 
-    def edit_workflow_aux(context_params)
-      assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
+    def edit_or_create_workflow_aux(context_params,opts={})
+      option_1 = (opts[:create] ? :option_1! : :option_1)
+      assembly_or_workspace_id, workflow_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,option_1],method_argument_names)
       post_body = {
-        :assembly_id => assembly_or_workspace_id,
-        :module_type => 'service_module',
+        :assembly_id       => assembly_or_workspace_id,
+        :module_type       => 'service_module',
         :modification_type => 'workflow'
       }
+      if workflow_name
+        post_body.merge!(:task_action => workflow_name)
+      end
+      if opts[:create]
+        post_body.merge!(:create => true)
+        post_body.merge!(:base_task_action => opts[:create_from]) if opts[:create_from]
+      end
       response = post rest_url("assembly/prepare_for_edit_module"), post_body
       return response unless response.ok?
+
       assembly_name,service_module_id,service_module_name,version,repo_url,branch,branch_head_sha,edit_file = response.data(:assembly_name,:module_id,:full_module_name,:version,:repo_url,:workspace_branch,:branch_head_sha,:edit_file)
       edit_opts = {
         :automatically_clone => true,
@@ -234,6 +284,7 @@ module DTK::Client
         :modification_type => :workflow,
         :edit_file => edit_file
       }
+      edit_opts.merge!(:task_action => workflow_name) if workflow_name
       version = nil #TODO: version associated with assembly is passed in edit_opts, which is a little confusing
       edit_aux(:service_module,service_module_id,service_module_name,version,edit_opts)
     end
@@ -257,14 +308,14 @@ module DTK::Client
     end
 
     def push_module_updates_aux(context_params)
-      assembly_or_workspace_id, component_module_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!],method_argument_names)
+      assembly_or_workspace_id, component_module_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID, :option_1!], method_argument_names)
       post_body = {
         :assembly_id => assembly_or_workspace_id,
         :module_name => component_module_name,
         :module_type => 'component_module'
       }
       post_body.merge!(:force => true) if options.force?
-      response = post(rest_url("assembly/promote_module_updates"),post_body)
+      response = post(rest_url('assembly/promote_module_updates'), post_body)
       return response unless response.ok?
       return Response::Ok.new() unless response.data(:any_updates)
       if dsl_parsing_errors = response.data(:dsl_parsing_errors)
@@ -272,11 +323,12 @@ module DTK::Client
         OsUtil.print(error_message, :red)
         return Response::NoOp.new()
       end
-      module_name,namespace,branch,ff_change = response.data(:module_name,:module_namespace,:workspace_branch,:fast_forward_change)
+      module_name, namespace, branch, ff_change = response.data(:module_name, :module_namespace, :workspace_branch, :fast_forward_change)
       ff_change ||= true
-      opts = {:local_branch => branch,:namespace => namespace}
-      opts.merge!(:hard_reset => true) if !ff_change
-      response = Helper(:git_repo).pull_changes?(:component_module,module_name,opts)
+      opts = { :local_branch => branch, :namespace => namespace }
+      opts.merge!(:hard_reset => true) unless ff_change
+      opts.merge!(:force => true) if options.force?
+      response = Helper(:git_repo).pull_changes?(:component_module, module_name, opts)
       return response unless response.ok?()
       Response::Ok.new()
     end
@@ -323,9 +375,9 @@ module DTK::Client
       response = Helper(:git_repo).pull_changes?(:component_module, module_name, edit_opts.merge!(opts))
       return response unless response.ok?()
 
-      edit_opts.merge!(:force_parse => true, :update_from_includes => true, :print_dependencies => true, :remote_branch => local_branch)
+      edit_opts.merge!(:force_parse => true, :update_from_includes => true, :print_dependencies => true, :remote_branch => local_branch, :force_clone => true)
       response = push_clone_changes_aux(:component_module, module_id, nil, "Pull base module updates", true, edit_opts)
-      
+
       unless response.ok?()
         # if parsing error on assembly module (components/attributes/link_defs integrity violations) do git reset --hard
         Helper(:git_repo).hard_reset_branch_to_sha(:component_module, module_name, edit_opts)
@@ -336,24 +388,46 @@ module DTK::Client
     end
 
     def workflow_info_aux(context_params)
-      assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
+      assembly_or_workspace_id,workflow_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1],method_argument_names)
       post_body = {
         :assembly_id => assembly_or_workspace_id,
         :subtype     => 'instance'
       }
+      post_body.merge!(:task_action => workflow_name) if workflow_name
       post(rest_url("assembly/info_about_task"),post_body)
     end
 
+    def workflow_list_aux(context_params)
+      assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
+      post_body = {
+        :assembly_id => assembly_or_workspace_id
+      }
+      response = post(rest_url("assembly/task_action_list"),post_body)
+      data_type = 'task_action'
+      response.render_table(data_type)
+    end
+
     def task_status_aw_aux(context_params)
       assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
-      response = task_status_aux(assembly_or_workspace_id,:assembly,:wait => options.wait?,:summarize => options.summarize?)
+      mode = 
+        if options.wait?
+          :refresh
+        else
+          if options.has_key?('mode') and options.mode.nil?
+            raise DtkError::Usage.new("option --mode needs an argument")
+          end
+         (options.mode || :snapshot).to_sym
+        end
+      response = task_status_aux(mode,assembly_or_workspace_id,:assembly,:summarize => options.summarize?)
 
       # TODO: Hack which is necessery for the specific problem (DTK-725), we don't get proper error message when there is a timeout doing converge
-      unless response == true
-        return response.merge("data" => [{ "errors" => {"message" => "Task does not exist for workspace."}}]) unless response["data"]
-        response["data"].each do |data|
-          if data["errors"]
-            data["errors"]["message"] = "[TIMEOUT ERROR] Server is taking too long to respond." if data["errors"]["message"] == "error"
+      unless mode == :stream
+        unless response == true
+          return response.merge("data" => [{ "errors" => {"message" => "Task does not exist for workspace."}}]) unless response["data"]
+          response["data"].each do |data|
+            if data["errors"]
+              data["errors"]["message"] = "[TIMEOUT ERROR] Server is taking too long to respond." if data["errors"]["message"] == "error"
+            end
           end
         end
       end
@@ -407,103 +481,6 @@ module DTK::Client
       list_aux(context_params)
     end
 
-    # desc "WORKSPACE-NAME/ID list-assemblies","List assemblies for current workspace."
-    # def list_assemblies(context_params)
-    #   data_type = :assembly
-    #   post_body = { :subtype  => 'instance', :detail_level => 'nodes' }
-    #   rest_endpoint = "assembly/list"
-    #   response = post rest_url(rest_endpoint), post_body
-
-    #   response.render_table(data_type)
-    #   return response
-    # end
-
-    # desc "WORKSPACE-NAME/ID list-assemblies","List assemblies for current workspace."
-    # def list_assemblies(context_params)
-    #   data_type = :assembly
-    #   post_body = { :subtype  => 'instance', :detail_level => 'nodes' }
-    #   rest_endpoint = "assembly/list"
-    #   response = post rest_url(rest_endpoint), post_body
-
-    #   response.render_table(data_type)
-    #   return response
-    # end
-
-    # desc "WORKSPACE-NAME/ID list-assemblies","List assemblies for current workspace."
-    # def list_assemblies(context_params)
-    #   workspace_id, node_id, component_id, attribute_id, about = context_params.retrieve_arguments([:workspace_id,:node_id,:component_id,:attribute_id,:option_1],method_argument_names)
-    #   detail_to_include = nil
-
-    #   if about
-    #     case about
-    #       when "nodes"
-    #         data_type = :node
-    #       when "components"
-    #         data_type = :component
-    #         detail_to_include = [:component_dependencies]
-    #       when "attributes"
-    #         data_type = :attribute
-    #         detail_to_include = [:attribute_links]
-    #       when "tasks"
-    #         data_type = :task
-    #       else
-    #         raise_validation_error_method_usage('list')
-    #     end
-    #   end
-
-    #   post_body = {
-    #     :assembly_id => workspace_id,
-    #     :node_id => node_id,
-    #     :component_id => component_id,
-    #     :subtype     => 'instance'
-    #   }
-    #   post_body.merge!(:detail_to_include => detail_to_include) if detail_to_include
-    #   rest_endpoint = "assembly/info_about"
-
-    #   if context_params.is_last_command_eql_to?(:attribute)
-    #     raise DTK::Client::DtkError, "Not supported command for current context level." if attribute_id
-    #     about, data_type = get_type_and_raise_error_if_invalid(about, "attributes", ["attributes"])
-    #   elsif context_params.is_last_command_eql_to?(:component)
-    #     if component_id
-    #       about, data_type = get_type_and_raise_error_if_invalid(about, "attributes", ["attributes"])
-    #     else
-    #       about, data_type = get_type_and_raise_error_if_invalid(about, "components", ["attributes", "components"])
-    #     end
-    #   elsif context_params.is_last_command_eql_to?(:node)
-    #     if node_id
-    #       about, data_type = get_type_and_raise_error_if_invalid(about, "components", ["attributes", "components"])
-    #       data_type = :workspace_attribute
-    #     else
-    #       about, data_type = get_type_and_raise_error_if_invalid(about, "nodes", ["attributes", "components", "nodes"])
-    #     end
-    #   else
-    #     if workspace_id
-    #       about, data_type = get_type_and_raise_error_if_invalid(about, "nodes", ["attributes", "components", "nodes", "tasks"])
-    #     else
-    #       data_type = :assembly
-    #       post_body = { :subtype  => 'instance', :detail_level => 'nodes' }
-    #       rest_endpoint = "assembly/list"
-    #     end
-    #   end
-
-    #   post_body[:about] = about
-    #   response = post rest_url(rest_endpoint), post_body
-
-    #   if (data_type.to_s.eql?("workspace_attribute") && response["data"])
-    #     response["data"].each do |data|
-    #       unless(data["linked_to_display_form"].to_s.empty?)
-    #         data_type = :workspace_attribute_w_link
-    #         break
-    #       end
-    #     end
-    #   end
-
-    #   # set render view to be used
-    #   response.render_table(data_type)
-
-    #   return response
-    # end
-
     def link_attribute_aux(context_params)
       assembly_or_workspace_id, target_attr_term, source_attr_term = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!,:option_2!],method_argument_names)
       post_body = {
@@ -514,22 +491,20 @@ module DTK::Client
       post rest_url("assembly/add_ad_hoc_attribute_links"), post_body
     end
 
-    def list_attribute_mappings_aux(context_params)
-      post_body = Helper(:service_link).post_body_with_id_keys(context_params,method_argument_names)
-      post rest_url("assembly/list_attribute_mappings"), post_body
-    end
-
     def create_component_aux(context_params)
       # If method is invoked from 'assembly/node' level retrieve node_id argument
       # directly from active context
       if context_params.is_there_identifier?(:node)
-        mapping = [REQ_ASSEMBLY_OR_WS_ID,:node_id!,:option_1!]
+        mapping = [REQ_ASSEMBLY_OR_WS_ID, :node_id!, :option_1!]
+        assembly_id, node_id, component_template_id = context_params.retrieve_arguments(mapping, method_argument_names)
       else
         # otherwise retrieve node_id from command options
-        mapping = [REQ_ASSEMBLY_OR_WS_ID,:option_1!,:option_2!]
+        mapping = [REQ_ASSEMBLY_OR_WS_ID, :option_1!]
+        assembly_id, component_template_id = context_params.retrieve_arguments(mapping, method_argument_names)
+        node_id = nil
       end
 
-      assembly_id,node_id,component_template_id = context_params.retrieve_arguments(mapping,method_argument_names)
+      # assembly_id,node_id,component_template_id = context_params.retrieve_arguments(mapping,method_argument_names)
       namespace, component_template_id = get_namespace_and_name_for_component(component_template_id)
 
       post_body = {
@@ -549,21 +524,24 @@ module DTK::Client
 
     def link_components_aux(context_params)
       post_body = link_unlink_components__ret_post_body(context_params)
-      post rest_url("assembly/add_service_link"), post_body
+      post rest_url('assembly/add_service_link'), post_body
     end
 
     def link_unlink_components__ret_post_body(context_params)
       if context_params.is_last_command_eql_to?(:component)
-        assembly_or_workspace_id,dep_cmp,antec_cmp,dependency_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:component_id!,:option_1!,:option_2],method_argument_names)
+        assembly_or_workspace_id, dep_cmp, antec_cmp, dependency_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID, :component_id!, :option_1!, :option_2], method_argument_names)
       else
-        assembly_or_workspace_id,dep_cmp,antec_cmp,dependency_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID,:option_1!,:option_2!,:option_3],method_argument_names)
+        assembly_or_workspace_id, dep_cmp, antec_cmp, dependency_name = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID, :option_1!, :option_2!, :option_3], method_argument_names)
       end
+
+      antec_cmp = "assembly_wide/#{antec_cmp}" unless antec_cmp.include?('/')
       post_body = {
         :assembly_id => assembly_or_workspace_id,
         :input_component_id => dep_cmp,
         :output_component_id => antec_cmp
       }
       post_body.merge!(:dependency_name => dependency_name) if dependency_name
+
       post_body
     end
 
@@ -593,15 +571,6 @@ module DTK::Client
       response.render_table(:possible_service_connection)
     end
 
-    def list_smoketests(context_params)
-      assembly_or_workspace_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID],method_argument_names)
-
-      post_body = {
-        :assembly_id => assembly_or_workspace_id
-      }
-      post rest_url("assembly/list_smoketests"), post_body
-    end
-
     def info_aux(context_params)
       assembly_or_workspace_id, node_id, component_id, attribute_id = context_params.retrieve_arguments([REQ_ASSEMBLY_OR_WS_ID, :node_id, :component_id, :attribute_id],method_argument_names)
       is_json_return = context_params.get_forwarded_options[:json_return] || false
@@ -726,18 +695,42 @@ module DTK::Client
 
     def set_attribute_aux(context_params)
       if context_params.is_there_identifier?(:attribute)
-        mapping = (options.unset? ? [REQ_ASSEMBLY_OR_WS_ID,:attribute_id!] : [REQ_ASSEMBLY_OR_WS_ID,:attribute_id!,:option_1!])
+        mapping = (options.unset? ? [REQ_ASSEMBLY_OR_WS_ID, :attribute_id!] : [REQ_ASSEMBLY_OR_WS_ID, :attribute_id!, :option_1!])
       else
-        mapping = (options.unset? ? [REQ_ASSEMBLY_OR_WS_ID,:option_1!] : [REQ_ASSEMBLY_OR_WS_ID,:option_1!,:option_2!])
+        mapping = (options.unset? ? [REQ_ASSEMBLY_OR_WS_ID, :option_1!] : [REQ_ASSEMBLY_OR_WS_ID, :option_1!, :option_2!])
       end
 
-      assembly_or_workspace_id, pattern, value = context_params.retrieve_arguments(mapping,method_argument_names)
+      assembly_or_workspace_id, pattern, value = context_params.retrieve_arguments(mapping, method_argument_names)
       post_body = {
         :assembly_id => assembly_or_workspace_id,
         :pattern => pattern
       }
+
+      raise DTK::Client::DtkValidationError, 'Please use only component-attribute (-c) or node-attribute (-n) option' if options.component_attribute? && options.node_attribute?
+
+      # if try to set service instance attribute but using -n option to sepicify it is node attribute, say that node attribute does not exist
+      raise DTK::Client::DtkError, "[ERROR] Node attribute '#{pattern}' does not exist" if options.node_attribute? && !pattern.include?('/')
+
+      # make sure -c and -n are used only with node or cmp attributes directly on service instance
+      validate_service_instance_node_or_cmp_attrs(pattern, options) if options.component_attribute? || options.node_attribute?
+
+      post_body.merge!(:component_attribute => true) if options.component_attribute?
+      post_body.merge!(:node_attribute => true) if options.node_attribute? || context_params.is_there_identifier?(:node)
       post_body.merge!(:value => value) unless options.unset?
-      post rest_url("assembly/set_attributes"), post_body
+
+      response = post rest_url('assembly/set_attributes'), post_body
+      return response unless response.ok?
+
+      if r_data = response.data
+        if r_data.is_a?(Hash) && (ambiguous = r_data['ambiguous'])
+          unless ambiguous.empty?
+            msg = "It is ambiguous whether '#{ambiguous.join(', ')}' #{ambiguous.size == 1 ? 'is' : 'are'} node or component attribute(s). Run set-attribute again with one of options -c [--component-attribute] or -n [--node-attribute]."
+            raise DTK::Client::DtkError, msg
+          end
+        end
+      end
+
+      Response::Ok.new()
     end
 
     def create_attribute_aux(context_params)
@@ -890,14 +883,24 @@ module DTK::Client
         return unless Console.confirmation_prompt("Are you sure you want to delete #{what} '#{component_id}'"+'?')
       end
 
+      if node_id.nil? && !(component_id.to_s =~ /^[0-9]+$/)
+        if component_id.to_s.include?('/')
+          node_id, component_id = component_id.split('/')
+          node_name = node_id
+        else
+          node_id = node_name = 'assembly_wide'
+        end
+      end
+
       post_body = {
         :assembly_id => assembly_or_workspace_id,
-        :node_id => node_id,
         :component_id => component_id
       }
 
       # delete component by name (e.g. delete-component dtk_java)
       post_body.merge!(:cmp_full_name => "#{node_name}/#{component_id}") if (node_name && !(component_id.to_s =~ /^[0-9]+$/))
+      post_body.merge!(:node_id => node_id) if node_id
+
       response = post(rest_url("assembly/delete_component"),post_body)
     end
 
@@ -1413,5 +1416,14 @@ module DTK::Client
       post rest_url("assembly/clear_tasks"), post_body
     end
 
+    def validate_service_instance_node_or_cmp_attrs(pattern, options)
+      split_pattern = pattern.split('/')
+      return if split_pattern.size == 2
+      if options.node_attribute?
+        raise DTK::Client::DtkError, 'Please use -n option only with service instance node attributes (node_name/attribute_name)'
+      elsif options.component_attribute?
+        raise DTK::Client::DtkError, 'Please use -c option only with service instance component attributes (cmp_name/attribute_name)'
+      end
+    end
   end
 end