dtk-shell 0.10.0

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

@@ -0,0 +1,72 @@
+#
+# 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
+  module PuppetForgeMixin
+
+    NAME_REGEX = /\w*\-\w/
+
+    def puppet_forge_install_aux(context_params, pf_module_name, module_name, namespace, version, module_type)
+      post_body_hash = {
+        :puppetf_module_name => pf_module_name,
+        :module_name?        => module_name,
+        :module_version?     => version,
+        :module_namespace?   => namespace
+      }
+
+      raise DtkError, "Puppet forge module name should be in format NAMESPACE-MODULENAME" unless pf_module_name.match(NAME_REGEX)
+
+      response = poller_response do
+        post rest_url("component_module/install_puppet_forge_modules"), PostBody.new(post_body_hash)
+      end
+
+      return response unless response.ok?
+
+
+      installed_modules = response.data(:installed_modules)
+
+      print_modules(response.data(:found_modules), 'using')
+      print_modules(installed_modules, 'installed')
+
+      main_module = response.data(:main_module)
+
+      unless installed_modules.empty?
+        # clone_deps = Console.confirmation_prompt("\nDo you want to clone newly installed dependencies?")
+        # if clone_deps
+        installed_modules.each do |im|
+          clone_aux(im['type'], im['id'], im['version'], true, true, {:backup_if_exist => true})
+        end
+        # end
+      end
+
+      clone_aux(main_module['type'], main_module['id'], main_module['version'], true, true, {:print_imported => true, :backup_if_exist => true})
+      nil
+  end
+
+    private
+
+    def print_modules(modules, action_name)
+      modules.each do |target_module|
+        module_name = full_module_name(target_module)
+        module_type = target_module['type']
+
+        print "#{action_name.capitalize} dependency #{module_type.gsub('_',' ')} '#{module_name}'\n"
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,101 @@
+#
+# 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
+  module PurgeCloneMixin
+    def purge_clone_aux(module_type, opts = {})
+      module_name = opts[:module_name]
+      version = opts[:version]
+      opts_module_loc = (opts[:assembly_module] ? {:assembly_module => opts[:assembly_module]} : Hash.new)
+      module_location = OsUtil.module_location(module_type, module_name, version, opts_module_loc)
+      dirs_to_delete = [module_location]
+      if opts[:delete_all_versions]
+        dirs_to_delete += OsUtil.module_version_locations(module_type, module_name, version, opts)
+      elsif opts[:all_except_base]
+        dirs_to_delete = OsUtil.module_version_locations(module_type, module_name, version, opts)
+      end
+      response = Response::Ok.new()
+      pwd = Dir.getwd()
+      dirs_to_delete.each do |dir|
+        if File.directory?(dir)
+          if ((pwd == dir) || (pwd.include?("#{dir}/")))
+            OsUtil.print("Local directory '#{dir}' is not deleted because it is your current working directory.", :yellow)
+          else
+            FileUtils.rm_rf(dir)
+          end
+        end
+      end
+      response
+    end
+
+    def check_if_unsaved_cmp_module_changes(assembly_or_workspace_id, opts={})
+      unsaved_modules = []
+      post_body = {
+        :assembly_id => assembly_or_workspace_id,
+        :subtype     => 'instance'
+      }
+      response = post rest_url("assembly/get_component_modules"), post_body
+
+      if response.ok?
+        response.data.each do |cmp_mod|
+          branch_relationship = cmp_mod['branch_relationship']||''
+          unsaved_modules << "#{cmp_mod['namespace_name']}:#{cmp_mod['display_name']}" if (cmp_mod['local_copy_diff'] && branch_relationship.eql?('local_ahead'))
+        end
+      end
+
+      unsaved_modules
+    end
+
+    def check_if_unsaved_assembly_changes(assembly_or_workspace_id, assembly_name, opts={})
+      post_body = {
+        :assembly_id => assembly_or_workspace_id,
+        :module_type => 'service_module',
+        :modification_type => 'workflow'
+      }
+      response = post rest_url("assembly/prepare_for_edit_module"), post_body
+      return 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,
+        :assembly_module => {
+          :assembly_name => assembly_name,
+          :version => version
+        },
+        :workspace_branch_info => {
+          :repo_url => repo_url,
+          :branch => branch,
+          :module_name => service_module_name
+        },
+        :commit_sha => branch_head_sha,
+        :pull_if_needed => true,
+        :modification_type => :workflow,
+        :edit_file => edit_file
+      }
+
+      version = nil #TODO: version associated with assembly is passed in edit_opts, which is a little confusing
+      module_location  = OsUtil.module_location(:service_module,service_module_name,version,edit_opts)
+      return unless File.directory?(module_location)
+
+      grit_adapter = Helper(:git_repo).create(module_location)
+      return unless grit_adapter.repo_exists?
+
+      grit_adapter.changed?
+    end
+
+  end
+end

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

@@ -0,0 +1,162 @@
+#
+# 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.
+#
+dtk_require_common_commands('thor/common')
+dtk_require_from_base('command_helpers/service_importer')
+
+module DTK::Client
+  module PushCloneChangesMixin
+    include CommonMixin
+    ##
+    #
+    # module_type: will be :component_module or :service_module
+    def push_clone_changes_aux(module_type, module_id, version, commit_msg, internal_trigger=false, opts={})
+      module_name, module_namespace, repo_url, branch, not_ok_response = workspace_branch_info(module_type, module_id, version, opts)
+      return not_ok_response if not_ok_response
+
+      full_module_name = ModuleUtil.resolve_name(module_name, module_namespace)
+      module_location  = OsUtil.module_location(module_type, full_module_name, version, opts)
+
+      unless File.directory?(module_location)
+        return if opts[:skip_cloning]
+        if opts[:force_clone] || Console.confirmation_prompt("Push not possible, module '#{module_name}#{version && "-#{version}"}' has not been cloned. Would you like to clone module now"+'?')
+          clone_aux(module_type, module_id, version, true, true, opts)
+        else
+          return
+        end
+      end
+
+      push_opts = opts.merge(:commit_msg => commit_msg, :local_branch => branch, :where => 'server')
+      response  = Helper(:git_repo).push_changes(module_type, full_module_name, version, push_opts)
+      return response unless response.ok?
+
+      json_diffs = (response.data(:diffs).empty? ? {} : JSON.generate(response.data(:diffs)))
+      commit_sha = response.data(:commit_sha)
+      repo_obj   = response.data(:repo_obj)
+      json_diffs = JSON.generate(response.data(:diffs))
+      post_body  = get_workspace_branch_info_post_body(module_type, module_id, version, opts).merge(:json_diffs => json_diffs, :commit_sha => commit_sha)
+
+      post_body.merge!(:modification_type => opts[:modification_type]) if opts[:modification_type]
+      post_body.merge!(:force_parse => true) if options['force-parse'] || opts[:force_parse]
+      post_body.merge!(:update_from_includes => true) if opts[:update_from_includes]
+      post_body.merge!(:service_instance_module => true) if opts[:service_instance_module]
+      post_body.merge!(:current_branch_sha => opts[:current_branch_sha]) if opts[:current_branch_sha]
+      post_body.merge!(:force => opts[:force]) if opts[:force]
+      post_body.merge!(:task_action => opts[:task_action]) if opts[:task_action]
+      post_body.merge!(:generate_docs => true) if opts[:generate_docs]
+      post_body.merge!(:use_impl_id => opts[:use_impl_id]) if opts[:use_impl_id]
+
+      if opts[:set_parsed_false]
+        post_body.merge!(:set_parsed_false => true)
+        post_body.merge!(:force_parse => true)
+      end
+
+      response = post(rest_url("#{module_type}/update_model_from_clone"), post_body)
+      return response unless response.ok?
+
+      external_dependencies = response.data(:external_dependencies)
+      dsl_parse_error       = response.data(:dsl_parse_error)
+      dsl_updated_info      = response.data(:dsl_updated_info)
+      dsl_created_info      = response.data(:dsl_created_info)
+      component_module_refs = response.data(:component_module_refs)
+
+      ret = Response::Ok.new()
+
+      # check if any errors
+      if dsl_parse_error
+        if parsed_external_dependencies = dsl_parse_error['external_dependencies']
+          external_dependencies = parsed_external_dependencies
+        else
+          err_msg_opts = { :module_type => module_type }
+          err_msg_opts.merge!(:command => opts[:command]) if opts[:command]
+          if err_message = ServiceImporter.error_message(module_name, dsl_parse_error, err_msg_opts)
+            DTK::Client::OsUtil.print(err_message, :red)
+            ret = Response::NoOp.new()
+          end
+        end
+      end
+
+      has_code_been_pulled = false
+
+      # check if server pushed anything that needs to be pulled
+
+      # we need to pull latest code in case docs where generated
+      OsUtil.print("Pulling generated documentation on your local repository ...", :yellow) if opts[:generate_docs]
+
+      if dsl_updated_info and !dsl_updated_info.empty?
+        if msg = dsl_updated_info["msg"]
+          DTK::Client::OsUtil.print(msg,:yellow)
+        end
+        new_commit_sha = dsl_updated_info[:commit_sha]
+        unless new_commit_sha and new_commit_sha == commit_sha
+          opts_pull = opts.merge(:local_branch => branch,:namespace => module_namespace)
+          resp = Helper(:git_repo).pull_changes(module_type, module_name, opts_pull)
+          has_code_been_pulled = true
+          return resp unless resp.ok?
+        end
+      end
+
+      # unless DSL was updated we pull latest code due to changes on documentation
+      if opts[:generate_docs] && !has_code_been_pulled
+        opts_pull = opts.merge(:local_branch => branch,:namespace => module_namespace)
+        resp = Helper(:git_repo).pull_changes(module_type, module_name, opts_pull)
+        return resp unless resp.ok?
+      end
+
+      if opts[:print_dependencies] || !internal_trigger
+        if external_dependencies
+          ambiguous        = external_dependencies["ambiguous"]||[]
+          amb_sorted       = ambiguous.map { |k,v| "#{k.split('/').last} (#{v.join(', ')})" }
+          inconsistent     = external_dependencies["inconsistent"]||[]
+          possibly_missing = external_dependencies["possibly_missing"]||[]
+          OsUtil.print("There are inconsistent module dependencies: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+          OsUtil.print("There are missing module dependencies: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+          OsUtil.print("There are ambiguous module dependencies: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
+        end
+      end
+
+      # check if server sent any file that should be added
+      if dsl_created_info and !dsl_created_info.empty?
+        path = dsl_created_info["path"]
+        content = dsl_created_info["content"]
+        if path and content
+          msg      = "A #{path} file has been created for you, located at #{repo_obj.repo_dir}"
+          response = Helper(:git_repo).add_file(repo_obj,path,content,msg)
+          return response unless response.ok?
+        end
+      end
+
+      unless (component_module_refs||{}).empty?
+        print_using_dependencies(component_module_refs)
+      end
+
+      ret
+    end
+
+    private
+
+    def print_using_dependencies(component_refs)
+      # TODO: This just prints out dircetly included modules
+      unless component_refs.empty?
+        puts 'Using component modules:'
+        component_refs.values.map { |r| "#{r['namespace_info']}:#{r['module_name']}" }.sort.each do |name|
+          puts "  #{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+#
+# 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.
+#
+dtk_require_common_commands('thor/common')
+dtk_require("../../../domain/git_adapter")
+
+
+module DTK::Client
+  module PushToRemoteMixin
+
+    NO_PUSH_CHANGES_MSG = "There are no changes to push"
+
+    def push_to_git_remote_aux(full_module_name, module_type, version, opts, force = false)
+      opts.merge!(:force => force)
+
+      response = Helper(:git_repo).push_changes(module_type, full_module_name, version, opts)
+
+      return response unless response.ok?
+      if response.data(:diffs) && !response.data(:diffs)[:are_there_changes]
+        raise DtkError, NO_PUSH_CHANGES_MSG
+      end
+
+      Response::Ok.new()
+    end
+
+    def push_to_git_remote_location_aux(full_module_name, module_type, version, opts, force = false)
+      opts.merge!(:force => force)
+
+      # staging dir which will be removed
+      temp_stage_dir = OsUtil.temp_git_remote_location()
+      content_dir    = File::join(temp_stage_dir, opts[:remote_repo_location])
+
+      begin
+        # clone desired repo
+        ::DTK::Client::GitAdapter.clone(opts[:remote_repo_url], temp_stage_dir, opts[:remote_branch])
+        # make sure that content dir exist
+        FileUtils.mkdir_p(content_dir)
+        # copy content of module to new dir (overriding everything in process)
+        module_location = OsUtil.module_location(module_type, full_module_name, version)
+        FileUtils.cp_r(File.join(module_location, '/.'), content_dir)
+        # remove git folder
+        FileUtils.rm_rf(File.join(content_dir, '.git'))
+        # now we push it
+        opts.merge!(:override_repo_dir_location => temp_stage_dir)
+        response = Helper(:git_repo).push_changes(module_type, full_module_name, version, opts)
+        return response unless response.ok?
+
+        if response.data(:diffs) && !response.data(:diffs)[:are_there_changes]
+          raise DtkError, NO_PUSH_CHANGES_MSG
+        end
+
+        Response::Ok.new()
+      ensure
+        FileUtils.rm_rf(temp_stage_dir)
+      end
+    end
+
+    def push_to_remote_aux(remote_module_info, module_type, force = false)
+      full_module_name     = remote_module_info.data(:full_module_name)
+      version = remote_module_info.data(:version)
+
+      opts = {
+        :remote_repo_url => remote_module_info.data(:remote_repo_url),
+        :remote_repo => remote_module_info.data(:remote_repo),
+        :remote_branch => remote_module_info.data(:remote_branch),
+        :local_branch => remote_module_info.data(:workspace_branch),
+        :where => 'catalog',
+        :force => force
+      }
+      response = Helper(:git_repo).push_changes(module_type, full_module_name, version, opts)
+      return response unless response.ok?
+      if response.data(:diffs) && !response.data(:diffs)[:are_there_changes]
+        raise DtkError, NO_PUSH_CHANGES_MSG
+      end
+
+      Response::Ok.new()
+    end
+
+  end
+end

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

@@ -0,0 +1,71 @@
+#
+# 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
+  module RemotesMixin
+
+    def remote_remove_aux(context_params)
+      module_id, remote_name = context_params.retrieve_arguments([::DTK::Client::ModuleMixin::REQ_MODULE_ID,:option_1!], method_argument_names)
+      module_type = get_module_type(context_params)
+
+      unless options.force
+        return unless Console.confirmation_prompt("Are you sure you want to remove '#{remote_name}'?")
+      end
+
+      post_body = {
+        "#{module_type}_id".to_sym => module_id,
+        :remote_name => remote_name
+      }
+
+      response = post rest_url("#{module_type}/remove_git_remote"), post_body
+      return response unless response.ok?
+      OsUtil.print("Successfully removed remote '#{remote_name}'", :green)
+      nil
+    end
+
+    def remote_add_aux(context_params)
+      module_id, remote_name, remote_url = context_params.retrieve_arguments([::DTK::Client::ModuleMixin::REQ_MODULE_ID,:option_1!,:option_2!], method_argument_names)
+      module_type = get_module_type(context_params)
+
+      post_body = {
+        "#{module_type}_id".to_sym => module_id,
+        :remote_name => remote_name,
+        :remote_url  => remote_url
+      }
+
+      response = post rest_url("#{module_type}/add_git_remote"), post_body
+      return response unless response.ok?
+      OsUtil.print("Successfully added remote '#{remote_name}'", :green)
+      nil
+    end
+
+    def remote_list_aux(context_params)
+      module_id   = context_params.retrieve_arguments([::DTK::Client::ModuleMixin::REQ_MODULE_ID], method_argument_names)
+      module_type = get_module_type(context_params)
+
+      post_body = {
+        "#{module_type}_id".to_sym => module_id
+      }
+
+      response = post rest_url("#{module_type}/info_git_remote"), post_body
+      response.render_table(:remotes)
+    end
+
+
+  end
+end