dtk-client 0.5.17 → 0.5.18

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjlmZmNkNDc5M2UxMjc5N2JhODE2MWJhNTVmYzc1M2RjMWJjZjk5ZQ==
+    Y2MwM2Q0NGFmOTdhNmZiYzUzMWNjMGNkMTg4YzM1YWFlN2Y2ZjJlMw==
   data.tar.gz: !binary |-
-    NTg2ZGMwMzhjZmY4MDkwM2JlZDcyODllMjkwOTcwMDEwZDg3ZDZkOQ==
+    OTY2OWU3ODA4OGFlZTAwMDZlNmUwOGNiMDA3MzVjZWJlYTk4ZjlmNA==
 SHA512:
   metadata.gz: !binary |-
-    NzVjZjZjY2M2ZmE1MWY5MzU2MzdmNzI0NmFlNWIzNmJlMDA0N2VkZDhiOWJk
-    OTJkMGIyMWQ2Y2FlYWNiNWQ1YWYzNTU4MmNmYmVlNTdlYjI2ZWU3NjUwMGY1
-    NTgzZjA5ODQ4YmZiMjhiZGJiMWY3MWFmOTQxNzIyNmRmMjJjMTI=
+    MmIxYjQ4ZGVhMDRlYjViODI5YzdjOTgzNjlmYTI5M2Y1NTdkOTc3YTEzZjk3
+    YmM2ZjRhYjVkODFmNjQwODRmMjdkZjRmMzY1ZmYyZGMxYzg4ZWM5MWE3MWIy
+    ZjdlODEyMTIwOWFmM2ViYTUyMzZkMTFmNDU4ZGQ5MGU2ZDg1NTQ=
   data.tar.gz: !binary |-
-    NTViMjM2NDZmNDU1MjQ1MmM5OWFiYmM1YzQzMDk1NjEyMTJhMjM2YTI1ZDdl
-    YTcxYTdmMmE2Y2NhMjZkNmJjMmM0ZDJlMGRkZmQ5MDU1ZGVmNTM3ZjA4NTg5
-    Yjg1ZDM2MzM3ZGYzODQ2NThiNzZiOTJmZDVmOGQ2Y2RmMzdlNjU=
+    ZWZkYjM2MzIzNmU5NGNlOTA0YTU3Zjk4NzU1MWU0ZDZlOGRmMTllYTFlM2U5
+    NjVlYjEzNzZkZTJjMzllYzg5ZWQzMmFmYThmM2U4MTM3MGNhYmE2M2UxMWYz
+    NTViYjlmNjAyOGViMjUyOTVmMjMyNGRhOWU3ZDNjMTNiZTdjZDg=

data/lib/command_helpers/git_repo.rb

@@ -1,3 +1,6 @@
+# This code is predciated on assumption that they is only one local branch (with with documented exceptions)
+# so checkout branch is not done in most cases
+#TODO : make sure all functions that use local_repo_dir( inside pass in full_moudle_name, not just module_name
 require 'fileutils'
 dtk_require("../domain/git_adapter")
 dtk_require("../domain/git_error_handler")
@@ -6,17 +9,20 @@ module DTK; module Client; class CommandHelper
   class GitRepo < self; class << self
 
     def create(repo_dir,branch=nil,opts={})
-      GitAdapter.new(repo_dir,branch,opts)
+      GitAdapter.new(repo_dir,branch)
     end
 
-    def create_clone_with_branch(type, module_name, repo_url, branch=nil, version=nil, opts={})
+    def create_clone_with_branch(type, module_name, repo_url, branch=nil, version=nil, module_namespace=nil, opts={})
       Response.wrap_helper_actions do
-        modules_dir = modules_dir(type,module_name,version,opts)
+        full_name = module_namespace ? ModuleUtil.resolve_name(module_name, module_namespace) : module_name
+
+        modules_dir = modules_dir(type,full_name,version,opts)
         FileUtils.mkdir_p(modules_dir) unless File.directory?(modules_dir)
-        target_repo_dir = local_repo_dir(type,module_name,version,opts)
+        target_repo_dir = local_repo_dir(type,full_name,version,opts)
+
         opts = {}
         opts = { :branch => branch } if branch
-        begin 
+        begin
           GitAdapter.clone(repo_url, target_repo_dir, opts[:branch])
         rescue => e
           # Handling Git error messages with more user friendly messages
@@ -27,7 +33,7 @@ module DTK; module Client; class CommandHelper
           error_msg = "Clone to directory (#{target_repo_dir}) failed"
 
           DtkLogger.instance.error_pp(e.message, e.backtrace)
-          
+
           raise ErrorUsage.new(error_msg,:log_error=>false)
         end
         {"module_directory" => target_repo_dir}
@@ -44,16 +50,6 @@ module DTK; module Client; class CommandHelper
       end
     end
 
-    def local_clone_dir_exists?(type,module_name,version=nil)
-      ret = local_repo_dir(type,module_name,version)
-      File.directory?(ret) && ret
-    end
-    def local_clone_exists?(type,module_name,version=nil)                  
-      repo_dir = local_repo_dir(type,module_name,version)
-      ret = "#{repo_dir}/.git"
-      File.directory?(ret) && ret
-    end
-
     #opts can have the following keys
     #
     #:remote_repo
@@ -62,9 +58,9 @@ module DTK; module Client; class CommandHelper
     #:local_branch
     #:no_fetch
     #
-    def push_changes(type,module_name,version,opts={})
+    def push_changes(type,full_module_name,version,opts={})
       Response.wrap_helper_actions() do
-        repo_dir = local_repo_dir(type,module_name,version,opts)
+        repo_dir = local_repo_dir(type,full_module_name,version,opts)
         repo = create(repo_dir,opts[:local_branch])
         push_repo_changes_aux(repo,opts)
       end
@@ -78,33 +74,51 @@ module DTK; module Client; class CommandHelper
       end
     end
 
-    #opts can have the following keys
-    #
-    #:remote_repo
-    #:remote_branch
-    #:remote_repo_url
-    #:local_branch
-    #:version
-    #:commit_sha
+    # opts can have the following keys
     #
+    # :remote_repo
+    # :remote_branch
+    # :remote_repo_url
+    # :local_branch
+    # :version
+    # :commit_sha
+    # :full_module_name
+    # :namespace
     # returns:
     # { :diffs => , :commit_sha => }
     def pull_changes(type,module_name,opts={})
       Response.wrap_helper_actions() do
-        repo_dir = local_repo_dir(type,module_name,opts[:version],opts)
+        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])
         response = pull_repo_changes_aux(repo,opts)
         response
       end
     end
     def pull_changes?(type,module_name,opts={})
-      if local_clone_exists?(type,module_name)
+      if local_clone_dir_exists?(type,module_name,opts)
         pull_changes(type,module_name,opts)
       else
-        Response.wrap_helper_actions() 
+        Response.wrap_helper_actions()
       end
     end
 
+    # opts can have the following keys
+    #
+    # :version
+    # :full_module_name
+    # :namespace
+    def local_clone_dir_exists?(type,module_name,opts={})
+      full_module_name = full_module_name(module_name,opts)
+      ret = local_repo_dir(type,full_module_name,opts[:version])
+      File.directory?(ret) && ret
+    end
+
+    def full_module_name(module_name,opts)
+      opts[:full_module_name] || ModuleUtil.resolve_name(module_name, opts[:namespace])
+    end
+    private :full_module_name
+
     def synchronize_clone(type,module_name,commit_sha,opts={})
       pull_changes?(type,module_name,{:commit_sha => commit_sha}.merge(opts))
       Response::Ok.new()
@@ -121,13 +135,14 @@ module DTK; module Client; class CommandHelper
       end
     end
 
-    def check_local_dir_exists_with_content(type,module_name,version=nil)
+    def check_local_dir_exists_with_content(type,module_name,version=nil,module_namespace=nil)
+      full_module_name = ModuleUtil.join_name(module_name, module_namespace)
       Response.wrap_helper_actions() do
         ret = Hash.new
-        local_repo_dir = local_repo_dir(type,module_name,version)
-        
+        local_repo_dir = local_repo_dir(type,full_module_name,version)
+
         unless File.directory?(local_repo_dir)
-          raise ErrorUsage.new("The content for module (#{module_name}) should be put in directory (#{local_repo_dir})")
+          raise ErrorUsage.new("The content for module (#{full_module_name}) should be put in directory (#{local_repo_dir})")
         end
 
         # transfered this part to initialize_client_clone_and_push because if we remove .git folder and
@@ -143,14 +158,33 @@ module DTK; module Client; class CommandHelper
         # end
 
         if Dir["#{local_repo_dir}/*"].empty?
-          raise ErrorUsage.new("Directory (#{local_repo_dir}) must have ths initial content for module (#{module_name})")
+          raise ErrorUsage.new("Directory (#{local_repo_dir}) must have ths initial content for module (#{full_module_name})")
         end
         {"module_directory" => local_repo_dir}
       end
     end
 
+    def rename_and_initialize_clone_and_push(type, module_name, new_module_name, branch, repo_url, local_repo_dir, version = nil)
+
+      # check to see if the new dir has proper naming e.g. (~/dtk/component_modules/dtk::java)
+      unless local_repo_dir.match(/\/#{new_module_name.gsub(ModuleUtil::NAMESPACE_SEPERATOR,'/')}$/)
+        old_dir = local_repo_dir
+        new_dir = local_repo_dir.gsub(/#{module_name}$/, new_module_name.split(ModuleUtil::NAMESPACE_SEPERATOR).join('/'))
+
+        # creates directory if missing
+        parent_path = new_dir.gsub(/(\/\w+)$/,'')
+        FileUtils::mkdir_p(parent_path) unless File.directory?(parent_path)
+        FileUtils.mv(old_dir, new_dir)
+      else
+        new_dir = local_repo_dir
+      end
+
+      # Continue push
+      initialize_client_clone_and_push(type, new_module_name, branch, repo_url, new_dir, version)
+    end
+
     # makes repo_dir (determined from type and module_name) into a git dir, pulls, adds, content and then pushes
-    def initialize_client_clone_and_push(type,module_name,branch,repo_url,local_repo_dir,version=nil)
+    def initialize_client_clone_and_push(type, module_name, branch, repo_url, local_repo_dir, version=nil)
       # moved this part from 'check_local_dir_exists_with_content' to this method since this only deletes .git folder
       # which can cause us problems if import fails
       if File.directory?("#{local_repo_dir}/.git")
@@ -161,7 +195,7 @@ module DTK; module Client; class CommandHelper
         end
         # we return to normal flow, since .git dir is removed
       end
-      
+
       Response.wrap_helper_actions() do
         ret = Hash.new
         repo_dir = local_repo_dir(type,module_name)
@@ -186,7 +220,7 @@ module DTK; module Client; class CommandHelper
       def self.new_version(repo)
         new(repo.new_version())
       end
-      
+
       def self.diff(repo,local_branch,remote_reference)
         new(repo.diff_summary(local_branch,remote_reference))
       end
@@ -206,7 +240,7 @@ module DTK; module Client; class CommandHelper
         changes
       end
     end
-    
+
     #returns hash with keys
     #: diffs - hash with diffs
     # commit_sha - sha of currenet_commit
@@ -215,7 +249,7 @@ module DTK; module Client; class CommandHelper
 
       # adding untracked files (newly added files)
       repo.stage_changes()
-      
+
       # commit if there has been changes
       if repo.changed?
         repo.commit(opts[:commit_msg]||"Pushing changes from client") #TODO: make more descriptive
@@ -224,12 +258,12 @@ module DTK; module Client; class CommandHelper
       if opts[:remote_repo] and opts[:remote_repo_url]
         repo.add_remote(opts[:remote_repo],opts[:remote_repo_url])
       end
-      
+
       unless opts[:no_fetch]
         repo.fetch(remote(opts[:remote_repo]))
       end
 
-      local_branch = repo.current_branch_name 
+      local_branch = repo.local_branch_name
 
       remote_branch_ref = remote_branch_ref(local_branch, opts)
 
@@ -251,7 +285,7 @@ module DTK; module Client; class CommandHelper
 
         diffs = DiffSummary.diff(repo,local_branch, remote_branch_ref)
 
-    
+
         if diffs.any_diffs?()
           repo.push(remote_branch_ref)
         end
@@ -277,14 +311,14 @@ module DTK; module Client; class CommandHelper
         repo.fetch(remote(opts[:remote_repo]))
       end
 
-      local_branch      = repo.current_branch_name
+      local_branch      = repo.local_branch_name
 
       remote_branch_ref = remote_branch_ref(local_branch, opts)
 
       commit_shas = Hash.new
       merge_rel   = repo.merge_relationship(:remote_branch,remote_branch_ref, :ret_commit_shas => commit_shas)
       commit_sha  = nil
-      
+
       if merge_rel == :equal
         commit_sha = commit_shas[:other_sha]
       elsif merge_rel == :no_remote_ref
@@ -295,7 +329,7 @@ module DTK; module Client; class CommandHelper
       # diffs = DiffSummary.diff_remote(repo,"remotes/#{remote_branch_ref}")
       diffs = DiffSummary.diff(repo,local_branch, remote_branch_ref)
       commit_sha = repo.find_remote_sha(remote_branch_ref)
-      
+
       {"diffs" => diffs, "commit_sha" => commit_sha, "repo_obj" => repo, "status" => repo.local_summary() }
     end
 
@@ -313,7 +347,7 @@ module DTK; module Client; class CommandHelper
 
       repo.fetch(remote(opts[:remote_repo]))
 
-      local_branch = repo.current_branch_name 
+      local_branch = repo.local_branch_name
       remote_branch_ref = remote_branch_ref(local_branch,opts)
 
       if opts[:hard_reset]
@@ -377,8 +411,8 @@ module DTK; module Client; class CommandHelper
       end
     end
 
-    def local_repo_dir(type,module_name,version=nil,opts={})
-      OsUtil.module_location(type,module_name,version,opts)
+    def local_repo_dir(type,full_module_name,version=nil,opts={})
+      OsUtil.module_location(type,full_module_name,version,opts)
     end
 
     def adapter_class()

data/lib/command_helpers/service_importer.rb

@@ -1,9 +1,9 @@
 dtk_require_from_base('configurator')
 module DTK::Client
   #
-  # Main purpose of this module is to recognize which local modules are missing based on 
+  # Main purpose of this module is to recognize which local modules are missing based on
   # name, namespace, version and for those missing component module module will call
-  # module#clone and module#import_dtkn method to get missing component modules 
+  # module#clone and module#import_dtkn method to get missing component modules
   #
   module ServiceImporter
     def create_missing_clone_dirs()
@@ -18,7 +18,7 @@ module DTK::Client
     ##
     # Method will trigger import for each missing module component
     #
-    def trigger_module_component_import(missing_component_list,opts={})      
+    def trigger_module_component_import(missing_component_list, required_components, opts={})
       puts "Auto-importing missing component module(s)"
       does_not_exist, modules_to_import = validate_missing_components(missing_component_list)
 
@@ -27,7 +27,13 @@ module DTK::Client
         OsUtil.print("You do no have access to component modules '#{module_names}' required by service module, or they do not exist on repo manager and will not be imported!", :yellow)
         return false unless Console.confirmation_prompt("Do you want to continue with import of available component modules and service module"+'?')
       end
-      
+
+      required_components.each do |r_module|
+        module_name = "#{r_module['namespace']}/#{r_module['name']}"
+        module_name += "-#{r_module['version']}" if r_module['version']
+        print "Using component module '#{module_name}'\n"
+      end
+
       modules_to_import.each do |m_module|
         module_name = "#{m_module['namespace']}/#{m_module['name']}"
         module_name += "-#{m_module['version']}" if m_module['version']
@@ -38,9 +44,9 @@ module DTK::Client
 
         response = ContextRouter.routeTask("component_module", "install", new_context_params, @conn)
         puts(response.data(:does_not_exist) ? response.data(:does_not_exist) : "Done.")
-        raise DTK::Client::DtkError, response.error_message unless response.ok?        
+        raise DTK::Client::DtkError, response.error_message unless response.ok?
       end
-      
+
       Response::Ok.new()
     end
 
@@ -78,21 +84,24 @@ module DTK::Client
     def resolve_missing_components(service_module_id, service_module_name, namespace_to_use, force_clone=false)
       # Get dependency component modules and cross reference them with local component modules
       module_component_list = post rest_url("service_module/list_component_modules"), { :service_module_id => service_module_id }
+
       local_modules, needed_modules = OsUtil.local_component_module_list(), Array.new
 
       if module_component_list
-        module_component_list.data.each do |dependency_module|
-          unless local_modules.include?(formated_name = formulate_module_name(dependency_module['display_name'], dependency_module['version']))
-            needed_modules << dependency_module.merge({'formated_name' => formated_name})
+        module_component_list.data.each do |cmp_module|
+          with_namespace = ModuleUtil.resolve_name(cmp_module["display_name"],cmp_module["namespace_name"])
+          formated_name = add_version?(with_namespace, cmp_module['version'])
+          unless local_modules.include?(formated_name)
+            needed_modules << cmp_module.merge({'formated_name' => formated_name})
           end
         end
       end
 
       unless needed_modules.empty?
-        puts "Service '#{service_module_name}' has following dependencies: \n\n"
-        needed_modules.each { |m| puts " - #{m['formated_name']}" }
+        # puts "Service '#{service_module_name}' does not have the following component modules dependencies on the client machine: \n\n"
+        # needed_modules.each { |m| puts " - #{m['formated_name']}" }
         is_install_dependencies = true
-        is_install_dependencies = Console.confirmation_prompt("\nDo you want to clone missing component module dependencies") unless force_clone
+        # is_install_dependencies = Console.confirmation_prompt("\nDo you want to clone these missing component modules to the client machine?") unless force_clone
 
         # we get list of modules available on server
 
@@ -101,7 +110,7 @@ module DTK::Client
         if is_install_dependencies
           needed_modules.each do |m|
             formated_name = m['formated_name']
-            print "Cloning component module '#{formated_name}' from server ... "
+            # print "Cloning component module '#{formated_name}' from server ... "
             thor_options = {}
             thor_options["version"] = m['version']
             thor_options["skip_edit"] = true
@@ -109,9 +118,9 @@ module DTK::Client
             thor_options.merge!(:module_type => 'component-module')
             new_context_params = ::DTK::Shell::ContextParams.new
             new_context_params.forward_options(thor_options)
-            new_context_params.add_context_to_params(formated_name, :"component-module", m['id'])             
+            new_context_params.add_context_to_params(formated_name, :"component-module", m['id'])
             response = ContextRouter.routeTask("component_module", "clone", new_context_params, @conn)
-            puts "Done."
+            # puts "Done."
           end
         end
       end
@@ -125,13 +134,13 @@ module DTK::Client
     def resolve_module_names(e)
       versions = (e['version'] ? e['version'].split(',') : ['CURRENT'])
 
-      versions.collect { |version| formulate_module_name(e['display_name'], version)}
+      versions.collect { |version| add_version?(e['display_name'], version)}
     end
 
     # Resolves local module name
     #
     # Returns: String
-    def formulate_module_name(display_name, version)
+    def add_version?(display_name, version)
       version = nil if 'CURRENT'.eql?(version)
       (version ? "#{display_name}-#{version.strip}" : "#{display_name}")
     end

data/lib/command_helpers/test_module_creator.rb

@@ -8,14 +8,15 @@ module DTK::Client
 				Response.wrap_helper_actions do
 		      modules_dir = OsUtil.test_clone_location()
 		      FileUtils.mkdir_p(modules_dir) unless File.directory?(modules_dir)
+		      module_name = ModuleUtil.filter_module_name(module_name)
 		      target_repo_dir = OsUtil.module_location(type,module_name)
 		      begin
-		      	FileUtils.mkdir(target_repo_dir)  
+		      	FileUtils.mkdir(target_repo_dir)
 		        generate_model(module_name, target_repo_dir)
-		        generate_serverspec_files(module_name, target_repo_dir)					
+		        generate_serverspec_files(module_name, target_repo_dir)
 		      rescue => e
 		        error_msg = "Create of directory (#{target_repo_dir}) failed."
-		        additional_error_msg = "Directory already exists" if e.message.include? "File exists" 
+		        additional_error_msg = "Directory already exists" if e.message.include? "File exists"
 		        raise DTK::ErrorUsage.new(error_msg + " " + additional_error_msg,:log_error=>false)
 		      end
 		      {"module_directory" => target_repo_dir}
@@ -41,8 +42,8 @@ module DTK::Client
 					File.open(target_repo_dir + "/serverspec/spec/localhost/temp_component_spec.rb", "w") { |f| f.write(spec_template) }
 				rescue => e
 					error_msg = "Generating serverspec files failed."
-		      DtkLogger.instance.error_pp(e.message, e.backtrace)        
-		      raise DTK::ErrorUsage.new(error_msg,:log_error=>false)				
+		      DtkLogger.instance.error_pp(e.message, e.backtrace)
+		      raise DTK::ErrorUsage.new(error_msg,:log_error=>false)
 				end
 			end
 		end

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

@@ -49,13 +49,14 @@ module DTK::Client
     def resolve_module_type
       case self
         when DTK::Client::ComponentModule
-          return 'component_module'
+          return :component_module
+        when DTK::Client::ServiceModule
+          return :service_module
         when DTK::Client::TestModule
-          return 'test_module'
+          return :test_module
         else
-          return 'service_module'
+          raise DtkError, "Module type cannot be resolved for this class (#{self})"
         end
-      # self.class == DTK::Client::ComponentModule ? 'component_module' : 'service_module'
     end
 
   end

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

@@ -0,0 +1,75 @@
+module DTK::Client
+  module AssemblyTemplateMixin
+    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
+
+    # the form should be
+    # SETTINGS := SETTING[;...SETTING]
+    # SETTING := ATOM || ATOM(ATTR=VAL,...)
+    def parse_service_settings(settings)
+       settings && settings.split(';').map{|setting|ServiceSetting.parse(setting)}
+    end
+
+    module ServiceSetting
+      def self.parse(setting)
+        if setting =~ /(^[^\(]+)\((.+)\)$/
+          name = $1
+          param_string = $2
+          {:name => name, :parameters => parse_params(param_string)}
+        else
+          {:name => setting}
+        end
+      end
+      private
+       def self.parse_params(param_string)
+         param_string.split(',').inject(Hash.new) do |h,av_pair|
+           if av_pair =~ /(^[^=]+)=(.+$)/
+             attr = $1
+             val = $2
+             h.merge(attr => val)
+           else
+             raise DtkError,"[ERROR] Settings param string is ill-formed"
+           end
+         end
+       end
+    end
+  end
+end