dtk-shell 0.10.0

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

@@ -0,0 +1,59 @@
+#
+# 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 BaseCommandHelper
+    def initialize(command,context_params=nil)
+      @command        = command
+      @context_params = context_params
+      @options        = command.options
+    end
+
+    def print_external_dependencies(external_dependencies, location)
+      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 mentioned #{location}: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+      OsUtil.print("There are missing module dependencies mentioned #{location}: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+      OsUtil.print("There are ambiguous module dependencies mentioned #{location}: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
+    end
+
+   private
+    def context_params()
+      @context_params ||  raise(DtkError, "[ERROR] @context_params is nil")
+    end
+
+    def retrieve_arguments(mapping, method_info = nil)
+      context_params.retrieve_arguments(mapping, method_info || @command.method_argument_names)
+    end
+
+    def get_namespace_and_name(*args)
+      @command.get_namespace_and_name(*args)
+    end
+
+    def rest_url(*args)
+      @command.rest_url(*args)
+    end
+
+    def post(*args)
+      @command.post(*args)
+    end
+
+  end
+end

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

@@ -0,0 +1,82 @@
+#
+# 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')
+module DTK::Client
+  module CloneMixin
+    extend Console
+    include CommonMixin
+    ##
+    #
+    # internal_trigger: this flag means that other method (internal) has trigger this.
+    #                   This will change behaviour of method
+    # module_type: will be :component_module or :service_module
+
+    def clone_aux(module_type, module_id, version, internal_trigger = false, omit_output = false, opts = {})
+      # if version = base do not clone latest, just base
+      if version && version.eql?('base')
+        version = nil
+        opts[:use_latest] = false
+      end
+
+      module_name, module_namespace, repo_url, branch, not_ok_response, version = workspace_branch_info(module_type, module_id, version, opts)
+      return not_ok_response if not_ok_response
+
+      # clone base version first if not cloned already
+      clone_base_aux(module_type, module_id, "#{module_namespace}:#{module_name}") if opts[:use_latest] && version
+
+     # TODO: DTK-2358: comenyed out because causing error in this jira; see if need to put in in revisedform to avoid this error; below is checking wromg thing ( module_location is set to wromg thing to check)
+      # module_location = OsUtil.module_location(module_type, "#{module_namespace}:#{module_name}", version)
+      # raise DTK::Client::DtkValidationError, "#{module_type.to_s.gsub('_',' ').capitalize} '#{module_name}#{version && "-#{version}"}' already cloned!" if File.directory?(module_location) && !opts[:skip_if_exist_check]
+
+      full_module_name = ModuleUtil.resolve_name(module_name, module_namespace)
+
+      # TODO: should we use instead Helper(:git_repo).create_clone_from_optional_branch
+      response = Helper(:git_repo).create_clone_with_branch(module_type,module_name,repo_url,branch,version,module_namespace,opts)
+
+      if response.ok?
+        print_name = "Module '#{full_module_name}'"
+        print_name << " version '#{version}'" if version
+        puts "#{print_name} has been successfully cloned!" unless omit_output
+        # when puppet forge import, print successfully imported instead of cloned
+        DTK::Client::OsUtil.print("#{print_name} has been successfully imported!", :yellow) if omit_output && opts[:print_imported]
+        unless internal_trigger
+          if Console.confirmation_prompt("Would you like to edit module now?")
+            context_params_for_module = create_context_for_module(full_module_name, module_type)
+            return edit(context_params_for_module)
+          end
+        end
+      end
+
+      response
+    end
+
+    # clone base module version
+    def clone_base_aux(module_type, module_id, full_module_name)
+      base_module_location = OsUtil.module_location(module_type, full_module_name, nil)
+      unless File.directory?(base_module_location)
+        clone_aux(module_type, module_id, nil, true)
+      end
+    end
+
+    def create_context_for_module(full_module_name, module_type)
+      context_params_for_module = DTK::Shell::ContextParams.new
+      context_params_for_module.add_context_to_params(full_module_name, module_type.to_s.gsub!(/\_/,'-').to_sym, full_module_name)
+      return context_params_for_module
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+#
+# 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 CommonMixin
+   private
+    # returns module_name, module_namespace, repo_url, branch, not_ok_response( only if error)
+    def workspace_branch_info(module_type, module_id, version, opts={})
+      # shortcut if have info about workspace branch already
+      if info = opts[:workspace_branch_info]
+        name_or_full_module_name = info[:module_name]
+        module_namespace, module_name = ModuleUtil.full_module_name_parts?(name_or_full_module_name)
+        module_namespace ||= info[:module_namespace]
+        ret = [module_name, module_namespace, info[:repo_url], info[:branch]]
+        unless  ret.find{|r|r.nil?}
+          return ret
+        end
+      end
+
+      # if 'base' returned as version set to nil; 'base' = 'master' = nil
+      version = nil if version == 'base'
+
+      post_body = get_workspace_branch_info_post_body(module_type, module_id, version, opts)
+      response = post(rest_url("#{module_type}/get_workspace_branch_info"),post_body)
+      unless response.ok?
+        ret = [nil, nil, nil, nil, response, nil]
+      else
+        m_name, m_namespace, repo_url, w_branch, version = response.data(:module_name, :module_namespace, :repo_url, :workspace_branch, :version)
+        ret = [m_name, m_namespace, repo_url, w_branch, nil]
+        ret << version if opts[:use_latest]
+      end
+      ret
+    end
+
+    def get_workspace_branch_info_post_body(module_type, module_id, version_explicit, opts={})
+      id_field = "#{module_type}_id"
+      post_body = {
+        id_field => module_id
+      }
+      assembly_module = opts[:assembly_module]
+      if version = version_explicit||(assembly_module && assembly_module[:version])
+        post_body.merge!(:version => version)
+      end
+      if assembly_module
+        post_body.merge!(:assembly_module => true,:assembly_name => assembly_module[:assembly_name])
+      end
+      if use_latest = opts[:use_latest]
+        post_body.merge!(:use_latest => use_latest)
+      end
+      post_body
+    end
+
+    def get_remote_module_info_aux(module_type, module_id, remote_namespace, version=nil, module_refs_content=nil, local_namespace=nil)
+      id_field      = "#{module_type}_id"
+      rsa_pub_value = SSHUtil.rsa_pub_key_content()
+
+      post_body = {
+        id_field => module_id,
+        :rsa_pub_key => rsa_pub_value,
+        :access_rights => "rw",
+        :action => "push"
+      }
+      post_body.merge!(:version => version) if version
+      post_body.merge!(:remote_namespace => remote_namespace) if remote_namespace
+      post_body.merge!(:local_namespace => local_namespace) if local_namespace
+      post_body.merge!(:module_ref_content => module_refs_content) if module_refs_content && !module_refs_content.empty?
+
+      response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)
+      RemoteDependencyUtil.print_dependency_warnings(response)
+      response
+    end
+
+  end
+end

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

@@ -0,0 +1,49 @@
+#
+# 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 Commands
+    module Common
+      class Base
+        def initialize(command_base,context_params)
+          @command_base = command_base
+          @context_params = context_params
+        end
+       private
+        def retrieve_arguments(mapping)
+          @context_params.retrieve_arguments(mapping,@command_base.method_argument_names())
+        end
+
+        def retrieve_option_hash(option_list)
+          ret = Hash.new
+          option_values = @context_params.retrieve_thor_options(option_list,@command_base.options)
+          option_values.each_with_index do |val,i|
+            unless val.nil?
+              key = option_list[i].to_s.gsub(/\!$/,'').to_sym
+              ret.merge!(key => val)
+            end
+          end
+          ret
+        end
+
+        def post(url_path,body=nil)
+          @command_base.post(@command_base.rest_url(url_path),body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+#
+# 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_base')
+module DTK; module Client; module Commands::Common
+  class CreateTarget < Base
+    # option_list is of form [:provider!, :region, :keypair, :security_group!] indcating what is optional and what is required
+    def execute(type, option_list)
+      # we use :target_id but that will return provider_id (another name for target template ID)
+      target_name = retrieve_arguments([:option_1])
+      iaas_properties = iaas_properties(type,option_list)
+      provider = iaas_properties.delete(:provider)
+      post_body = {
+        :type             => type.to_s,
+        :provider_id      => provider,
+        :iaas_properties  => iaas_properties
+      }
+
+      # cleanup for target name not being sterilazied correctly
+      post_body.merge!(:target_name => target_name.split(' ').first) if target_name
+
+      post 'target/create', post_body
+    end
+
+   private
+    def iaas_properties(type, option_list)
+      iaas_properties = retrieve_option_hash(option_list)
+      special_processing_security_groups!(iaas_properties)
+      special_processing_region!(iaas_properties)
+      iaas_properties
+    end
+
+    def special_processing_region!(iaas_properties)
+      if region = iaas_properties[:region]
+        Shell::InteractiveWizard.validate_region(region)
+      end
+      iaas_properties
+    end
+
+    def special_processing_security_groups!(iaas_properties)
+      if security_group = iaas_properties[:security_group]
+        if security_group.end_with?(',')
+          raise DtkValidationError.new("Multiple security groups should be separated with ',' and without spaces between them (e.g. --security_groups gr1,gr2,gr3,...) ")
+        end
+        security_groups = security_group.split(',')
+
+        unless security_groups.empty? || security_groups.size==1
+          iaas_properties.delete(:security_group)
+          iaas_properties.merge!(:security_group_set => security_groups)
+        end
+      end
+      iaas_properties
+    end
+
+  end
+end; end; end

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

@@ -0,0 +1,255 @@
+#
+# 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/clone')
+dtk_require_common_commands('thor/push_clone_changes')
+dtk_require_common_commands('thor/pull_clone_changes')
+dtk_require_common_commands('thor/reparse')
+require 'yaml'
+
+module DTK::Client
+  module EditMixin
+    include CloneMixin
+    include PushCloneChangesMixin
+    include PullCloneChangesMixin
+    include ReparseMixin
+
+    ##
+    #
+    # module_type: will be one of
+    # :component_module
+    # :service_module
+    def edit_aux(module_type,module_id,module_name,version,opts={})
+      module_location  = OsUtil.module_location(module_type,module_name,version,opts)
+
+      pull_if_needed = opts[:pull_if_needed]
+      # check if there is repository cloned
+      unless File.directory?(module_location)
+        if opts[:automatically_clone] or Console.confirmation_prompt("Edit not possible, module '#{module_name}#{version && "-#{version}"}' has not been cloned. Would you like to clone module now"+'?')
+          internal_trigger = true
+          omit_output = true
+          response = clone_aux(module_type,module_id,version,internal_trigger,omit_output,opts)
+          # if error return
+          return response unless response.ok?
+          pull_if_needed = false
+        else
+          # user choose not to clone needed module
+          return
+        end
+      end
+      # here we should have desired module cloned
+
+      if pull_if_needed
+        response = pull_clone_changes?(module_type,module_id,version,opts)
+        return response unless response.ok?
+      end
+      grit_adapter = Helper(:git_repo).create(module_location)
+      if edit_info = opts[:edit_file]
+        #TODO: cleanup so dont need :base_file_name
+        file_to_edit =
+          if edit_info.kind_of?(String)
+            edit_info
+          else #edit_info.kind_of?(Hash) and has key :base_file_name
+            base_file = edit_info[:base_file_name]
+            (File.exists?("#{module_location}/#{base_file}.yaml") ? "#{base_file}.yaml" : "#{base_file}.json")
+          end
+        OsUtil.edit("#{module_location}/#{file_to_edit}")
+        OsUtil.print("If you want to use different editor please set environment variable EDITOR and log back into dtk-shell!", :yellow) unless ENV['EDITOR']
+      else
+        Console.unix_shell(module_location, module_id, module_type, version)
+      end
+
+      unless grit_adapter.repo_exists?
+        puts "Local module has been removed, skipping changes."
+        return Response::Ok.new()
+      end
+
+      unless grit_adapter.changed?
+        puts "No changes to repository"
+        return Response::Ok.new()
+      end
+
+      unless file_to_edit
+        grit_adapter.print_status
+      end
+
+      # check to see if auto commit flag
+      auto_commit  = ::DTK::Configuration.get(:auto_commit_changes)
+      confirmed_ok = false
+
+      # if there is no auto commit ask for confirmation
+      unless auto_commit
+        confirm_msg =
+          if file_to_edit
+            "Would you like to commit changes to the file?"
+          else
+            "Would you like to commit ALL the changes?"
+          end
+        confirmed_ok = Console.confirmation_prompt_simple(confirm_msg)
+      end
+      if (auto_commit || confirmed_ok)
+        if auto_commit
+          puts "[NOTICE] You are using auto-commit option, all changes you have made will be commited."
+        end
+        commit_msg = user_input("Commit message")
+
+        # remove qoutes if they are not closed properly in commit_msg
+        commit_msg.gsub!(/\"/,'') unless commit_msg.count('"') % 2 ==0
+
+        internal_trigger=true
+        reparse_aux(module_location)
+
+        # use_impl_id - if edit-component-module which has version use impl_id from assembly--<assembly_name> version of component instance
+        opts.merge!(:force_parse => true, :update_from_includes => true, :print_dependencies => true, :use_impl_id => true)
+        response = push_clone_changes_aux(module_type,module_id,version,commit_msg,internal_trigger,opts)
+
+        # if error return
+        return response unless response.ok?
+      end
+
+      #TODO: temporary took out; wil put back in
+      #puts "DTK SHELL TIP: Adding the client configuration parameter <config param name>=true will have the client automatically commit each time you exit edit mode" unless auto_commit
+      Response::Ok.new()
+    end
+
+    # returns text string with edited yaml content
+    def attributes_editor(yaml_input)
+      dtk_folder = OsUtil.dtk_local_folder
+      file_path = "#{dtk_folder}/temp_attrs.yaml"
+      File.open(file_path, 'w'){|f| f << yaml_input}
+      OsUtil.edit(file_path)
+      OsUtil.print("If you want to use different editor please set environment variable EDITOR and log back into dtk-shell!", :yellow) unless ENV['EDITOR']
+      edited_yaml = File.open(file_path,'r'){|f|f.read}
+      File.unlink(file_path)
+      edited_yaml
+    end
+   private
+    # removes any nil values and returns hash; also modifies any term that does not serialize
+    def post_process(object)
+      ret = Hash.new
+      if object.kind_of?(Hash)
+        post_process__hash(object)
+      elsif object.kind_of?(Array)
+        post_process__array(object)
+      elsif object.kind_of?(FalseClass)
+        Response::Term::Boolean.false
+      else
+        object
+      end
+    end
+
+    def post_process__hash(hash)
+      ret = Hash.new
+      hash.each_pair do |k,v|
+        processed_val = post_process(v)
+        #processed_val can be false so explicitly checking against nil
+        unless processed_val.nil?
+          ret.merge!(k => processed_val)
+        end
+      end
+      ret
+    end
+
+    def post_process__array(array)
+      ret = Array.new
+      array.each do |a|
+        # explicit nil not removed
+        if a.nil?
+          ret << Response::Term.nil()
+        else
+          processed_val = post_process(a)
+          #processed_val can be false so explicitly checking against nil
+          unless processed_val.nil?
+            ret << processed_val
+          end
+        end
+      end
+      ret
+    end
+  end
+end
+
+
+=begin
+    # TODO: probably deprecate
+    def attribute_header()
+      header_string =
+      "#############################\n####  REQUIRED ATTRIBUTES\n#############################\n#\n"
+    end
+    # TODO: probably deprecate
+    def attributes_editor_old_form(attributes,format)
+      if (format.eql?('yaml'))
+        dtk_folder = OsUtil.dtk_local_folder
+        file_path = "#{dtk_folder}/temp_attrs.yaml"
+
+        first_iteration_keys, first_iteration_values = [], []
+        second_iteration_keys, second_iteration_values = [], []
+        required_attributes = []
+
+        attribute_pairs = YAML.load(attributes)
+
+        attribute_pairs.each do |k,v|
+          first_iteration_keys << k
+
+          #prepare required attributes for editor display
+          if v.eql?("*REQUIRED*")
+            required_attributes << k
+            attribute_pairs[k] = nil
+            v = nil
+          end
+
+          first_iteration_values << v
+        end
+
+        File.open(file_path, 'w') do |out|
+          # print out required attributes
+          unless required_attributes.empty?
+            out.write(attribute_header())
+            required_attributes.each do |req_attr|
+              out.write("##{req_attr}\n")
+            end
+            out.write("#\n")
+          end
+
+          YAML.dump(attribute_pairs, out)
+        end
+
+        OsUtil.edit(file_path)
+        OsUtil.print("If you want to use different editor please set environment variable EDITOR and log back into dtk-shell!", :yellow) unless ENV['EDITOR']
+        begin
+          edited = YAML.load_file(file_path)
+        rescue Psych::SyntaxError => e
+          raise DSLParsing::YAMLParsing.new("YAML parsing error #{e} in file",file_path)
+        end
+
+        edited.each do |k,v|
+          second_iteration_keys << k
+          second_iteration_values << v
+        end
+
+        unless first_iteration_keys == second_iteration_keys
+          edited_keys = second_iteration_keys.select{|k| !first_iteration_keys.include?(k)}
+          raise DtkValidationError, "You have changed key(s) '#{edited_keys}'. We do not support key editing yet!"
+        end
+
+        raise DtkValidationError, "No attribute changes have been made." if ((first_iteration_keys == second_iteration_keys) && (first_iteration_values == second_iteration_values))
+        edited
+      else
+        raise DtkValidationError, "Unsupported format type '#{format.to_s}'!"
+      end
+    end
+=end