dtk-client 0.10.2 → 0.10.3

data/lib/client/operation/client_module_dir/git_repo.rb

@@ -19,6 +19,8 @@ module DTK::Client
   class Operation::ClientModuleDir
     # Operations for managing module folders that are git repos
     class GitRepo < self
+      require_relative('git_repo/internal')
+
       def self.commit_and_push_to_service_repo(args)
         wrap_operation(args) do |args| 
           response_data_hash(:head_sha => Internal.commit_and_push_to_service_repo(args))
@@ -53,12 +55,56 @@ module DTK::Client
         end
       end
 
-      def self.create_add_remote_and_pull(args)
+      def self.create_empty_repo?(args)
+        wrap_operation(args) do |args|
+          repo_dir  = args.required(:repo_dir)
+          Internal.create_empty_git_repo?(repo_dir)
+          response_data_hash
+        end
+      end
+
+      def self.create_repo_with_empty_commit(args)
+        wrap_operation(args) do |args|
+          repo_dir   = args.required(:repo_dir)
+          commit_msg = args[:commit_msg]
+          repo = Internal.create_empty_git_repo?(repo_dir)
+          response_data_hash(:head_sha => Internal.empty_commit(repo, commit_msg))
+        end
+      end
+
+      def self.fetch_dtkn_remote(args)
+        wrap_operation(args) do |args|
+          repo_with_remote = repo_with_dtkn_remote(args)
+
+          repo_with_remote.fetch
+          response_data_hash
+        end
+      end
+
+      def self.merge_from_dtkn_remote(args)
         wrap_operation(args) do |args|
-          repo_dir      = args.required(:repo_dir)
-          repo_url      = args.required(:repo_url)
           remote_branch = args.required(:remote_branch)
-          response_data_hash(:head_sha => Internal.create_add_remote_and_pull(repo_dir, repo_url, remote_branch))
+          no_commit     = args[:no_commit]
+          repo_with_remote  = repo_with_dtkn_remote(args)
+
+          response_data_hash(:head_sha => repo_with_remote.merge_from_remote(remote_branch, :no_commit => no_commit))
+        end
+      end
+
+      def self.checkout_branch__return_repo(args)
+        wrap_operation(args) do |args|
+          repo_dir     = args.required(:repo_dir)
+          local_branch = args.required(:local_branch)
+          response_data_hash(:repo => Internal.checkout_branch__return_repo(repo_dir, local_branch))
+        end
+      end
+
+      def self.stage_and_commit(args)
+        wrap_operation(args) do |args| 
+          repo_dir          = args.required(:repo_dir)
+          local_branch_type = args.required(:local_branch_type)
+          commit_msg        = args[:commit_msg]
+          response_data_hash(:head_sha => Internal.stage_and_commit(repo_dir, local_branch_type, :commit_msg => commit_msg))
         end
       end
 
@@ -74,6 +120,12 @@ module DTK::Client
         end
       end
 
+      def self.modified_with_diff(args)
+        wrap_operation(args) do |args|
+          response_data_hash(:modified => Internal.modified(args, :with_diffs => true))
+        end
+      end
+
       def self.init_and_push_from_existing_repo(args)
         wrap_operation(args) do |args|
           repo_dir      = args.required(:repo_dir)
@@ -107,259 +159,31 @@ module DTK::Client
         end
       end
 
-      private
-
-      def self.response_data_hash(hash)
-        hash.inject({}) { |h, (k, v)| h.merge(k.to_s => v) }
-      end
-
-      # All Internal methods do not have wrap_operation and can only be accessed by a method that wraps it
-      class Internal < self
-        # Git Params for dtk server
-        module Dtk_Server
-          GIT_REMOTE   = 'dtk-server'
-        end
-        # Git params for dtkn
-        module Dtkn
-          GIT_REMOTE   = 'dtkn'
-          LOCAL_BRANCH = 'master'
-        end
-
-        # returns head_sha
-        def self.commit_and_push_to_service_repo(args)
-          branch           = args.required(:branch)
-          remote_branch    = args[:remote_branch] || branch
-          service_instance = args.required(:service_instance)
-          commit_message   = args[:commit_message]
-
-          repo_dir = ret_base_path(:service, service_instance)
-          repo = git_repo.new(repo_dir, :branch => branch)
-          repo.stage_and_commit
-          # TODO: want to switch over to using Dtk_Server::GIT_REMOTE rather than 'origin'
-          dtk_server_remote = 'origin'
-          repo.push(dtk_server_remote, remote_branch)
-          repo.head_commit_sha
-        end
-
-        def self.clone_service_repo(args)
-          repo_url         = args.required(:repo_url)
-          branch           = args.required(:branch)
-          service_instance = args.required(:service_instance)
-          remove_existing  = args[:remove_existing]
-          repo_dir         = args[:repo_dir]
-
-          target_repo_dir = create_service_dir(service_instance, :remove_existing => remove_existing, :path => repo_dir)
-          begin
-            git_repo.clone(repo_url, target_repo_dir,  branch)
-          rescue => e
-            #cleanup by deleting directory
-            
-            FileUtils.rm_rf(target_repo_dir) if File.directory?(target_repo_dir)
-            # Log error details
-            Logger.instance.error_pp(e.message, e.backtrace)
-            
-            # User-friendly error
-            raise Error::Usage, "Clone to directory '#{target_repo_dir}' failed"
-          end
-          target_repo_dir
-        end
-
-        def self.clone_module_repo(args)
-          module_type     = args.required(:module_type)
-          repo_url        = args.required(:repo_url)
-          branch          = args.required(:branch)
-          module_name     = args.required(:module_name)
-          remove_existing = args[:remove_existing]
-          repo_dir        = args[:repo_dir]
-
-          target_repo_dir = create_module_dir(module_type, module_name, :remove_existing => remove_existing, :path => repo_dir)
-          begin
-            git_repo.clone(repo_url, target_repo_dir,  branch)
-          rescue => e
-            FileUtils.rm_rf(target_repo_dir) if File.directory?(target_repo_dir)
-            Logger.instance.error_pp(e.message, e.backtrace)
-
-            raise Error::Usage, "Clone to directory '#{target_repo_dir}' failed"
-          end
-
-          target_repo_dir
-        end
-        
-        def self.fetch_merge_and_push(args)
-          repo_dir      = args.required(:repo_dir)
-          repo_url      = args.required(:repo_url)
-          remote_branch = args.required(:branch)
-          
-          head_sha =
-            if git_repo.is_git_repo?(repo_dir)
-              init_and_push_from_existing_repo(repo_dir, repo_url, remote_branch)
-            else
-              create_repo_from_remote_and_push(repo_dir, repo_url, remote_branch)
-            end
-          
-          head_sha 
-        end
-        
-        def self.modified(args)
-          repo_url = args.required(:path)
-          branch   = args.required(:branch)
-          repo     = git_repo.new(repo_url, :branch => branch)
-
-          changed = repo.changed?
-          repo.print_status if changed
-          changed
-        end
-
-        def self.create_add_remote_and_push(repo_dir, repo_url, remote_branch)
-          repo = git_repo.new(repo_dir)
-          add_remote_and_push(repo, repo_url, remote_branch)
-          repo.head_commit_sha
-        end
-
-        def self.create_add_remote_and_pull(repo_dir, repo_url, remote_branch)
-          repo = create_repo_from_dtkn_remote(repo_dir, repo_url, remote_branch)
-          add_dtkn_remote_and_pull(repo, repo_url, remote_branch)
-          repo.head_commit_sha
-        end
-        
-        def self.init_and_push_from_existing_repo(repo_dir, repo_url, remote_branch)
-          repo = git_repo.new(repo_dir)
-          
-          if repo.is_there_remote?(Dtk_Server::GIT_REMOTE)
-            push_when_there_is_dtk_remote(repo, repo_dir, repo_url, remote_branch)
-          else
-            add_remote_and_push(repo, repo_url, remote_branch)
-          end
-          
-          repo.head_commit_sha
-        end
-        
-        def self.pull_from_remote(args)
-          repo_url       = args.required(:repo_url)
-          remote_branch  = args.required(:branch)
-          repo_dir       = args.required(:repo_dir)
-          
-          repo = git_repo.new(repo_dir, :branch => remote_branch)
-          repo.pull(repo.remotes.first, remote_branch)
-        end
-        
-        # returns the repo
-        def self.pull_from_service_repo(args)
-          repo_url         = args.required(:repo_url)
-          remote_branch    = args.required(:branch)
-          service_instance = args.required(:service_instance)
-          
-          repo_dir = ret_base_path(:service, service_instance)
-          repo = git_repo.new(repo_dir, :branch => remote_branch)
-          
-          repo.pull(repo.remotes.first, remote_branch)
-          repo
-        end
-
-        def self.push_when_there_is_dtk_remote(repo, repo_dir, repo_url, remote_branch)
-          # if there is only one remote and it is dtk-server; remove .git and initialize and push as new repo to dtk-server remote
-          # else if multiple remotes and dtk-server being one of them; remove dtk-server; add new dtk-server remote and push
-          if repo.remotes.size == 1
-            git_repo.unlink_local_clone?(repo_dir)
-            create_repo_from_remote_and_push(repo_dir, repo_url, remote_branch)
-          else
-            repo.remove_remote(Dtk_Server::GIT_REMOTE)
-            add_remote_and_push(repo, repo_url, remote_branch)
-          end
-        end
-
-        def self.create_repo_from_server_remote(repo_dir, repo_url, remote_branch)
-          repo = git_repo.new(repo_dir, :branch => Dtkn::LOCAL_BRANCH)
-          repo.checkout(Dtkn::LOCAL_BRANCH, :new_branch => true)
-          repo.add_remote(Dtk_Server::GIT_REMOTE, repo_url)
-          repo
-        end
-
-        def self.create_repo_from_dtkn_remote(repo_dir, repo_url, remote_branch)
-          repo = git_repo.new(repo_dir, :branch => Dtkn::LOCAL_BRANCH)
-          repo.checkout(Dtkn::LOCAL_BRANCH, :new_branch => true)
-          repo.stage_and_commit
-          repo.add_remote(Dtkn::GIT_REMOTE, repo_url)
-          repo
-        end
-
-        def self.create_repo_from_remote_and_push(repo_dir, repo_url, remote_branch)
-          repo = create_repo_from_server_remote(repo_dir, repo_url, remote_branch)
-          # repo = git_repo.new(repo_dir, :branch => Dtkn::LOCAL_BRANCH)
-          # repo.checkout(Dtkn::LOCAL_BRANCH, :new_branch => true)
-          # repo.add_remote(Dtk_Server::GIT_REMOTE, repo_url)
-          repo.stage_and_commit
-          repo.push(Dtk_Server::GIT_REMOTE, remote_branch, { :force => true })
-          repo.head_commit_sha
-        end
-        
-        def self.add_remote_and_push(repo, repo_url, remote_branch)
-          repo.add_remote(Dtk_Server::GIT_REMOTE, repo_url)
-          repo.stage_and_commit
-          repo.push(Dtk_Server::GIT_REMOTE, remote_branch, { :force => true })
-        end
-
-        def self.add_dtkn_remote_and_pull(repo, repo_url, remote_branch)
-          repo.add_remote(Dtkn::GIT_REMOTE, repo_url)
-          repo.pull(Dtkn::GIT_REMOTE, remote_branch)
-        end
-        
-        def self.add_service_repo_file(args)
-          branch           = args.required(:branch)
-          service_instance = args.required(:service_instance)
-          path             = args.required(:path)
-          content          = args.required(:content)
-          checkout_branch(service_instance, branch) do
-            File.open(qualified_path(service_instance, path), 'w') { |f| f.write(content) }
-          end
-        end
-
-        # returns content if file exists
-        def self.get_service_repo_file_content(args)
-          branch           = args.required(:branch)
-          service_instance = args.required(:service_instance)
-          path             = args.required(:path)
-          checkout_branch(service_instance, branch) do
-            qualified_path = qualified_path(service_instance, path)
-            if File.exists?(qualified_path)
-              File.open(qualified_path, 'r').read
-            end
-          end
+      def self.all_branches(args)
+        wrap_operation(args) do |args|
+          response_data_hash(:branches => Internal.all_branches(args))
         end
+      end
 
-        def self.git_repo
-          ::DTK::Client::GitRepo
+      def self.current_branch(args)
+        wrap_operation(args) do |args|
+          response_data_hash(:branch => Internal.current_branch(args))
         end
+      end
 
-        private
 
-        # relative_path is relative to top-leel repo directory
-        def self.qualified_path(service_instance, relative_path)
-          repo_dir = ret_base_path(:service, service_instance)
-          "#{repo_dir}/#{relative_path}"
-        end
+      private
 
-        CHECKOUT_LOCK = Mutex.new
-        def self.checkout_branch(service_instance, branch, &body)
-          ret = nil
-          CHECKOUT_LOCK.synchronize do
-            repo = git_repo.new(ret_base_path(:service, service_instance), :branch => branch)
-            current_branch = repo.current_branch.name
-            if current_branch == branch
-              ret = yield
-            else
-              begin
-                repo.checkout(branch) 
-                ret = yield
-              ensure
-                repo.checkout(current_branch)
-              end
-            end
-          end
-          ret
-        end
+      def self.repo_with_dtkn_remote(args)
+        info_type = args.required(:info_type)
+        repo_dir  = args.required(:repo_dir)
+        Internal::Dtkn.repo_with_remote(info_type, repo_dir, add_remote: args[:add_remote])
+      end
 
+      def self.response_data_hash(hash = {})
+        hash.inject({}) { |h, (k, v)| h.merge(k.to_s => v) }
       end
+
     end
   end
 end

data/lib/client/operation/client_module_dir.rb

@@ -106,8 +106,8 @@ module DTK::Client
         "#{OsUtil.current_dir}/#{name.gsub(':','/')}"
       end
 
-      def self.purge_service_instance_dir(dir_path)
-        FileUtils.rm_rf(dir_path)
+      def self.rm_f(path)
+        FileUtils.rm_rf(path)
       end
 
       def self.delete_directory_content(path)

data/lib/client/operation/module/clone_module.rb

@@ -18,37 +18,53 @@
 module DTK::Client
   class Operation::Module
     class CloneModule < self
+      attr_reader :module_ref, :target_repo_dir, :module_name, :version
+      def initialize(module_name, module_ref, target_directory)
+        @module_name     = module_name
+        @module_ref      = module_ref
+        @target_repo_dir = target_directory || ClientModuleDir.ret_path_with_current_dir(module_name)
+        @version         = module_ref.version
+      end
+      private :initialize
+
       def self.execute(args = Args.new)
         wrap_operation(args) do |args|
           module_ref       = args.required(:module_ref)
           module_name      = args.required(:module_name)
           target_directory = args[:target_directory]
-          
-          opts = {
-            :namespace => module_ref.namespace, 
-            :version => module_ref.version
-          }
-
-          unless module_info = module_exists?(module_ref, :type => :common_module)
-            raise Error::Usage, "DTK module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, opts)}' does not exist on server."
-          end
-
-          branch    = module_info.required(:branch, :name)
-          repo_url  = module_info.required(:repo, :url)
-          repo_name = module_info.required(:repo, :name)
-
-          clone_args = {
-            :module_type => :common_module,
-            :repo_url    => module_info.required(:repo, :url),
-            :branch      => module_info.required(:branch, :name),
-            :module_name => module_name,
-            :repo_dir    => target_directory || ClientModuleDir.ret_path_with_current_dir(module_name)
-            # :remove_existing  => remove_existing
-          }
-
-          ret = ClientModuleDir::GitRepo.clone_module_repo(clone_args)
-          OsUtil.print_info("DTK module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, opts)}' has been successfully cloned into '#{ret.required(:target_repo_dir)}'")
+          new(module_name, module_ref, target_directory).clone_module
+        end
+      end
+
+      def clone_module
+        opts = {
+          :namespace => module_ref.namespace,
+          :version => version
+        }
+
+        unless module_info = module_version_exists?(module_ref, :type => :common_module, :remote_info => true, :rsa_pub_key => SSHUtil.rsa_pub_key_content)
+          raise Error::Usage, "DTK module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, opts)}' does not exist on server."
         end
+
+        branch    = module_info.required(:branch, :name)
+        repo_url  = module_info.required(:repo, :url)
+        repo_name = module_info.required(:repo, :name)
+
+        clone_args = {
+          :module_type => :common_module,
+          :repo_url    => module_info.required(:repo, :url),
+          :branch      => module_info.required(:branch, :name),
+          :module_name => module_name,
+          :repo_dir    => target_repo_dir
+        }
+
+        ret = ClientModuleDir::GitRepo.clone_module_repo(clone_args)
+
+        if module_info.data(:component_info) || module_info.data(:service_info)
+          LoadSource.fetch_from_remote(module_info, self)
+        end
+
+        OsUtil.print_info("DTK module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, opts)}' has been successfully cloned into '#{ret.required(:target_repo_dir)}'")
       end
     end
   end

data/lib/client/operation/module/delete_from_remote.rb

@@ -0,0 +1,79 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::Module
+    class DeleteFromRemote < self
+      attr_reader :module_ref
+
+      def initialize(catalog, module_ref)
+        @catalog    = catalog
+        @module_ref = module_ref
+      end
+      private :initialize
+
+      def self.execute(args = Args.new)
+        wrap_operation(args) do |args|
+          module_ref  = args.required(:module_ref)
+          new('dtkn', module_ref).delete_from_remote(:skip_prompt => args[:skip_prompt])
+        end
+      end
+      
+      def delete_from_remote(opts = {})
+        query_string_hash = QueryStringHash.new(
+          :module_name => module_ref.module_name,
+          :namespace   => module_ref.namespace,
+          :rsa_pub_key => SSHUtil.rsa_pub_key_content,
+        )
+
+        unless version = module_ref.version
+          remotes = Operation::Module.list_remotes({})
+
+          selected_module = remotes.data.find{ |vr| vr['display_name'].eql?("#{module_ref.namespace}/#{module_ref.module_name}") }
+          raise Error::Usage, "Module '#{module_ref.namespace}/#{module_ref.module_name}' does not exist on repo manager!" unless selected_module
+
+          versions = selected_module['versions']
+          versions.map! { |v| v == 'base' ? 'master' : v }
+
+          if versions.size > 1
+            ret_version = Console.version_prompt(versions, "Select which module version to delete: ", { :add_all => true })
+            return unless ret_version
+            version = ret_version
+          else
+            version = versions.first
+          end
+        end
+
+        query_string_hash.merge!(:version => version)
+        query_string_hash.merge!(:versions => versions) if version.eql?('all')
+
+        unless opts[:skip_prompt]
+          module_ref_opts = { :namespace => module_ref.namespace }
+          module_ref_opts.merge!(:version => version) unless version.eql?('all')
+          return unless Console.prompt_yes_no("Are you sure you want to delete module '#{DTK::Common::PrettyPrintForm.module_ref(module_ref.module_name, module_ref_opts)}' from repo manager?", :add_options => true)
+        end
+
+        rest_post "#{BaseRoute}/delete_from_remote", query_string_hash
+
+        nil
+      end
+
+    end
+  end
+end
+
+

data/lib/client/operation/module/install/common_module.rb

@@ -20,36 +20,25 @@ module DTK::Client
     class CommonModule < self
       BaseRoute = 'modules'
 
-      def self.install(module_ref, file_obj)
-        post_body = PostBody.new(
+      # opts can have keys:
+      #   :has_remote_repo
+      def self.install(module_ref, file_obj, opts = {})
+        common_post_body = PostBody.new(
           :module_name => module_ref.module_name,
           :namespace   => module_ref.namespace,
           :version?    => module_ref.version
         )
 
-        response = rest_post("#{BaseRoute}/create_empty_module", post_body)
+        create_post_body = common_post_body.merge(:has_remote_repo? => opts[:has_remote_repo]) 
+        response = rest_post("#{BaseRoute}/create_empty_module", create_post_body)
 
         branch    = response.required(:branch, :name)
         repo_url  = response.required(:repo, :url)
-        repo_name = response.required(:repo, :name)
 
-        # making repo dir to be directory that directly holds the base file object file_obj
-        repo_dir = file_obj.parent_dir
-
-        args = {
-          :repo_dir => repo_dir,
-          :repo_url => repo_url,
-          :branch   => branch
-        }
-
-        git_response = ClientModuleDir::GitRepo.fetch_merge_and_push(args)
-
-        post_body.merge!(
-          :repo_name  => repo_name,
-          :commit_sha => git_response.data(:head_sha)
-        )
-
-        rest_post("#{BaseRoute}/update_from_repo", post_body)
+        repo_dir = file_obj.parent_dir # repo dir is directory that directly holds the base file object file_obj
+        git_response = ClientModuleDir::GitRepo.fetch_merge_and_push(:repo_dir => repo_dir, :repo_url => repo_url, :branch => branch)
+        commit_sha     = git_response.data(:head_sha)
+        rest_post("#{BaseRoute}/update_from_repo", common_post_body.merge(:commit_sha => commit_sha))
       end
     end
   end

data/lib/client/operation/module/install/dependent_modules/component_dependency_tree/cache.rb

@@ -0,0 +1,47 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::Module::Install::DependentModules::ComponentDependencyTree
+    class Cache < ::Hash
+      # hash where key unqiuely determines module_refs and value is to hash with keys :module_ref and :dependencies 
+      def initialize
+        super()
+      end
+
+      def add!(module_ref, dependencies)
+        self[index(module_ref)] ||= {:module_ref => module_ref, :dependencies => dependencies }
+      end
+
+      def lookup_dependencies?(module_ref)
+        (self[index(module_ref)] || {})[:dependencies]
+      end
+
+      def all_modules_refs
+        values.map { |hash| hash[:module_ref] }
+      end
+
+      private
+
+      def index(module_ref)
+        "#{module_ref.module_name}--#{module_ref.namespace}--#{module_ref.version}"
+      end
+
+    end
+  end
+end
+