dtk-client 0.9.1 → 0.10.0

data/lib/util/dtk_puppet.rb

@@ -1,65 +0,0 @@
-#
-# 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.
-#
-# TODO-REMOVE: Check if we need this anymore
-
-module DTK
-  module Client
-    #
-    # Class is used as puppet wrapper, at the moment it will use console comamnds, later
-    # to be replaced with direct usage of puppet code, or re-implentation of their direct calls
-    #
-    class DtkPuppet
-
-      MODULE_PATH = OsUtil.component_clone_location()
-
-      # installs puppet module from puppet forge via puppet module
-      # method will print out progress or errrors
-      #
-      # Returns: Name of directory where module is saved
-      def self.install_module(module_name)
-        output = nil
-
-        OsUtil.suspend_output do
-          output = `puppet module install #{module_name} --modulepath #{MODULE_PATH} --force --render-as json`
-        end
-
-        # extract json from output, regex will match json in string
-        matched = output.match(/\{.+\}/)
-
-        raise DTK::Client::DtkError, "Puppet module '#{module_name}' not found." unless matched
-
-        # parse matched json
-        result = JSON.parse(matched[0])
-
-        if result['result'] == 'failure'
-          # we remove puppet specific messages
-          filtered = result['error']['multiline'].gsub(/^.*puppet module.*$\n?/,'')
-          # we strip and join multiline message
-          filtered = filtered.split(/\n/).map(&:strip).join(', ')
-          raise DTK::Client::DtkError, filtered
-        end
-
-        # puppet uses last part of the module name, as dir for location
-        dir_name = module_name.split('-').last
-        puts "Successfully installed '#{module_name}' from puppet forge, location: '#{MODULE_PATH}/#{dir_name}'"
-        return dir_name
-      end
-
-    end
-  end
-end

data/lib/util/module_util.rb

@@ -1,66 +0,0 @@
-#
-# 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
-  module Client
-    module ModuleUtil
-
-      NAMESPACE_SEPERATOR = ':'
-
-      def self.resolve_name(module_name, module_namespace)
-        is_invalid = module_name.nil? || module_namespace.nil? || module_name.empty? || module_namespace.empty?
-        raise DtkError, "Failed to provide module name (#{module_name}) or namespace (#{module_namespace})" if is_invalid
-        "#{module_namespace}#{NAMESPACE_SEPERATOR}#{module_name}"
-      end
-
-      def self.join_name(module_name, module_namespace)
-        module_namespace ? resolve_name(module_name, module_namespace) : module_name
-      end
-
-      def self.module_name(module_type)
-        module_type.to_s.gsub('_',' ')
-      end
-
-      # returns [namespace,name]; namespace can be null if cant determine it
-      def self.full_module_name_parts?(name_or_full_module_name)
-        if name_or_full_module_name.nil?
-          return [nil,nil]
-        end
-        if name_or_full_module_name =~ Regexp.new("(^.+)#{NAMESPACE_SEPERATOR}(.+$)")
-          namespace,name = [$1,$2]
-        else
-          namespace,name = [nil,name_or_full_module_name]
-        end
-        [namespace,name]
-      end
-
-      def self.filter_module_name(name_or_full_module_name)
-        full_module_name_parts?(name_or_full_module_name).last
-      end
-
-      def self.check_format!(module_identifier)
-        return module_identifier if module_identifier.match(/^[0-9]+$/)
-        DtkLogger.instance.debug(caller)
-        raise DtkError, "Module name should be in following format NAMESPACE#{NAMESPACE_SEPERATOR}MODULE_NAME" unless module_identifier.match(Regexp.new("^.+#{NAMESPACE_SEPERATOR}.+$"))
-      end
-
-      def self.type_to_sym(module_type_s)
-        module_type_s.to_s.gsub!(/\_/,'-').to_sym
-      end
-    end
-  end
-end

data/lib/util/os_util.rb

@@ -1,385 +0,0 @@
-#
-# 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_from_base('domain/response')
-dtk_require_from_base('auxiliary')
-require 'highline'
-require 'readline'
-
-module DTK
-  module Client
-    module OsUtil
-
-      extend Auxiliary
-
-      DTK_IDENTITY_FILE = 'dtk.pem'
-
-      class << self
-        def is_mac?
-          RUBY_PLATFORM.downcase.include?('darwin')
-        end
-
-        def is_windows?
-          RUBY_PLATFORM =~ /mswin|mingw|cygwin/
-        end
-
-        def is_linux?
-          RUBY_PLATFORM.downcase.include?('linux')
-        end
-
-        def get_temp_location
-          is_windows? ? genv(:temp) : '/tmp'
-        end
-
-        def pop_readline_history(number_of_last_commands)
-          number_of_last_commands.downto(1) do
-            Readline::HISTORY.pop
-          end
-          nil
-        end
-
-        def get_log_location
-          return "#{dtk_local_folder}"
-        end
-
-        def clear_screen
-          command = is_windows? ? "cls" : "clear"
-          system(command)
-        end
-
-        def dtk_home_dir
-          return "#{home_dir}"
-        end
-
-        # This will return class object from DTK::Client namespace
-        def get_dtk_class(command_name)
-          begin
-            Object.const_get('DTK').const_get('Client').const_get(cap_form(command_name))
-          rescue Exception => e
-            return nil
-          end
-        end
-
-        # for Windows app folder is already under OS username
-        def dtk_user_app_folder
-          if is_windows?
-            dtk_app_folder()
-          else
-            "#{dtk_app_folder}#{::DTK::Common::Aux.running_process_user()}/"
-          end
-        end
-
-        def dtk_app_folder
-          return (is_windows? ? "#{genv(:homedrive)}#{genv(:homepath)}/dtk/" : "#{/etc/}dtk/")
-        end
-
-        def dtk_local_folder
-          return (is_windows? ? "#{genv(:homedrive)}#{genv(:homepath)}/dtk/" : "#{home_dir}/dtk/")
-        end
-
-        def home_dir
-          return (is_windows? ? "#{genv(:homedrive)}#{genv(:homepath)}" : "#{genv(:home)}")
-        end
-
-        def current_dir
-          current_dir = Dir.getwd()
-          current_dir.gsub(home_dir, '~')
-        end
-
-        def genv(name)
-          return ENV[name.to_s.upcase].gsub(/\\/,'/')
-        end
-
-        def edit(file)
-          editor = ENV['EDITOR']
-          if is_windows?
-            raise Client::DtkError, "Environment variable EDITOR needs to be set; exit dtk-shell, set variable and log back into dtk-shell." unless editor
-          else
-            editor = 'vim' unless editor
-          end
-
-          system("#{editor} #{file}")
-        end
-
-        def module_location(module_type,module_name,version=nil,opts={})
-          # compact used because module_name can be nil
-          location = module_location_parts(module_type,module_name,version,opts).compact.join('/')
-          location
-        end
-
-        # if module location is /a/b/d/mod it returns ['/a/b/d','mod']
-        def module_location_parts(module_type,module_name,version=nil,opts={})
-          base_path = clone_base_path(opts[:assembly_module] ? :assembly_module : module_type)
-          if assembly_module = opts[:assembly_module]
-            assembly_name = opts[:assembly_module][:assembly_name]
-            base_all_types = "#{base_path}/#{assembly_name}"
-            if module_type == :all
-              [base_all_types,nil]
-            else
-              type = clone_base_path(module_type).split('/').last
-              ["#{base_all_types}/#{type}", module_name]
-            end
-          else
-            # we detect if we are using full name
-            if (module_name.match(/(.*)#{ModuleUtil::NAMESPACE_SEPERATOR}(.*)/))
-              [base_path, "#{$1}", "#{$2}#{version && "-#{version}"}"]
-            else
-              [base_path, "#{module_name}#{version && "-#{version}"}"]
-            end
-          end
-        end
-
-        def module_version_locations(module_type, module_name, version = nil, opts={})
-          base_path, namespace, name = module_location_parts(module_type, module_name, version, opts) #.first
-          namespace_path = "#{base_path}/#{namespace}"
-          module_versions = Dir.entries(namespace_path).select{|a| a.match(/^#{name}-\d{1,2}.\d{1,2}.\d{1,2}$/)}
-          module_versions.map{ |version| "#{namespace_path}/#{version}" }
-        end
-
-        def module_clone_location(module_type)
-          case module_type.to_s
-            when "component_module"
-              return component_clone_location
-            when "service_module"
-              return service_clone_location
-            when "test_module"
-              test_clone_location
-            else
-              raise Client::DtkError, "Unexpected module_type (#{module_type}) when determining module location"
-            end
-        end
-
-        def temp_git_remote_location()
-          File::join(dtk_local_folder, 'temp_remote_location')
-        end
-
-        def component_clone_location()
-          clone_base_path(:component_module)
-        end
-
-        def service_clone_location()
-          clone_base_path(:service_module)
-        end
-
-        def test_clone_location()
-          clone_base_path(:test_module)
-        end
-
-        def assembly_module_base_location()
-          clone_base_path(:assembly_module)
-        end
-
-        def backups_location()
-          path = Config[:backups_location]
-          final_path = path && path.start_with?('/') ? path : "#{dtk_local_folder}#{path}"
-          final_path.gsub(/\/$/,'')
-        end
-
-        def clone_base_path(module_type)
-
-          path =
-            case module_type.to_sym
-              when :service_module then Config[:service_location]
-              when :component_module then Config[:module_location]
-              when :test_module then Config[:test_module_location]
-              when :assembly_module then Config[:assembly_module_base_location]
-              else raise Client::DtkError, "Unexpected module_type (#{module_type}) when determining base path"
-            end
-
-
-          final_path = path && path.start_with?('/') ? path : "#{dtk_local_folder}#{path}"
-          # remove last slash if set in configuration by mistake
-          final_path.gsub(/\/$/,'')
-        end
-
-        #
-        # Checks to find dtk.pem in configuration node, if not found displays tip message
-        #
-        def dtk_identity_file_location()
-          path_to_identity_file = "#{dtk_local_folder}#{DTK_IDENTITY_FILE}"
-          return path_to_identity_file if File.exists?(path_to_identity_file)
-          print("TIP: You can save your identity file as '#{path_to_identity_file}' and it will be used as default identityfile.", :yellow)
-          nil
-        end
-
-
-        private :clone_base_path
-        #
-        #
-        #
-        def local_component_module_list()
-          component_module_dir = component_clone_location()
-
-          directories = Dir.entries(component_module_dir).map do |entry|
-            next if (entry =='.' || entry == '..' || entry.index('.') == 0 || !File.directory?(entry))
-
-            Dir.entries("#{component_module_dir}/#{entry}").map do |m_entry|
-              next unless File.directory? File.join(component_module_dir,entry,m_entry)
-              next if (m_entry =='.' || m_entry == '..' || m_entry.index('.') == 0)
-
-              ModuleUtil.join_name(m_entry, entry)
-            end
-          end
-
-          directories.flatten.select { |d| !d.nil? }
-        end
-
-        # Public method will convert given string, to string with colorize output
-        #
-        # message - String to be colorized
-        # color   - Symbol describing color to be used
-        #
-        # Returns String with colorize output
-        def colorize(message, color)
-          # at the moment we do not support colors in windows
-          ((is_windows? || message.nil?) ? message : message.colorize(color))
-        end
-
-        # Public method will print to STDOUT with given color
-        #
-        # message - String to be colorize and printed
-        # color   - Symbol describing the color to be used on STDOUT
-        #
-        # Void
-        def print(message, color = :white)
-          puts colorize(message, color)
-        end
-
-        def print_warning(message)
-          print(message, :yellow)
-        end
-
-        def print_deprecate_message(message)
-          print_warning(message)
-        end
-
-        # Public block, method will suspend STDOUT, STDERR in body of it
-        #
-        # Example
-        # suspend_output do
-        #   # some calls
-        # end
-        def suspend_output
-          if is_windows?
-            retval = yield
-          else
-            orig_stderr = $stderr.clone
-            orig_stdout = $stdout.clone
-            begin
-              $stderr.reopen File.new('/dev/null', 'w')
-              $stdout.reopen File.new('/dev/null', 'w')
-              retval = yield
-            rescue Exception => e
-              $stdout.reopen orig_stdout
-              $stderr.reopen orig_stderr
-              raise e
-            ensure
-              $stdout.reopen orig_stdout
-              $stderr.reopen orig_stderr
-            end
-          end
-          retval
-        end
-
-        def which(cmd)
-          exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-            exts.each { |ext|
-              exe = File.join(path, "#{cmd}#{ext}")
-              return exe if File.executable? exe
-            }
-          end
-          return nil
-        end
-
-        def dev_reload_shell()
-          suspend_output do
-            load File.expand_path('../../lib/util/os_util.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/util/ssh_util.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/util/remote_dependency_util.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/help_monkey_patch.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/domain/context_entity.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/domain/active_context.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/domain/context_params.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/domain/override_tasks.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/context.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/domain/git_adapter.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/command_helpers/git_repo.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/command_helpers/service_importer.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/view_processor/table_print.rb', File.dirname(__FILE__))
-            load File.expand_path('../../lib/shell/interactive_wizard.rb', File.dirname(__FILE__))
-            paths = []
-            paths << File.expand_path('../../lib/commands/thor/*.rb', File.dirname(__FILE__))
-            paths << File.expand_path('../../lib/commands/common/thor/*.rb', File.dirname(__FILE__))
-
-            paths.each do |path|
-              Dir[path].each do |thor_class_file|
-                load thor_class_file
-              end
-            end
-          end
-        end
-
-        def put_warning(prefix, text, color)
-          width = HighLine::SystemExtensions.terminal_size[0] - (prefix.length + 1)
-          text_split = wrap(text, width)
-          Kernel.print colorize(prefix, color), " "
-          text_split.lines.each_with_index do |line, index|
-            line = " "*(prefix.length + 1) + line unless index == 0
-            puts line
-          end
-        end
-
-        def wrap(text, wrap_at)
-          wrapped = [ ]
-          text.each_line do |line|
-          # take into account color escape sequences when wrapping
-          wrap_at = wrap_at + (line.length - actual_length(line))
-          while line =~ /([^\n]{#{wrap_at + 1},})/
-            search  = $1.dup
-            replace = $1.dup
-            if index = replace.rindex(" ", wrap_at)
-              replace[index, 1] = "\n"
-              replace.sub!(/\n[ \t]+/, "\n")
-              line.sub!(search, replace)
-            else
-              line[$~.begin(1) + wrap_at, 0] = "\n"
-            end
-          end
-          wrapped << line
-          end
-          return wrapped.join
-        end
-
-        def actual_length( string_with_escapes )
-          string_with_escapes.to_s.gsub(/\e\[\d{1,2}m/, "").length
-        end
-
-        def remove_html_tags(string_with_tags)
-          string_with_tags.gsub(/<\/?[^>]+>/, '')
-        end
-
-        private
-
-        def seperator
-          return (is_windows? ? "\\" : "/")
-        end
-      end
-    end
-  end
-end

data/lib/util/remote_dependency_util.rb

@@ -1,84 +0,0 @@
-#
-# 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.
-#
-#
-# Managment of remote dependencies detection (print warning) or providing data from local resources
-#
-module DTK
-  module Client
-    module RemoteDependencyUtil
-      MODULE_REF_FILE = 'module_refs.yaml'
-
-      class << self
-        def print_dependency_warnings(response, success_msg = nil, opts = {})
-          are_there_warnings = false
-          return are_there_warnings if response.nil? || response.data.nil?
-
-          warnings = response.data['dependency_warnings']
-          if warnings && !warnings.empty?
-            if opts[:ignore_permission_warnings]
-              warnings.delete_if { |warning| warning['error_type'].eql?('no_permission') }
-              return if warnings.empty?
-            end
-            print_out "Following warnings have been detected for current module by Repo Manager:\n"
-            warnings.each { |w| print_out("  - #{w['message']}") }
-            puts
-            are_there_warnings = true
-          end
-          print_out success_msg, :green if success_msg
-          are_there_warnings
-        end
-
-        def check_permission_warnings(response)
-          errors = ''
-          dependency_warnings = response.data['dependency_warnings']
-
-          if dependency_warnings && !dependency_warnings.empty?
-            no_permissions = dependency_warnings.select { |warning| warning['error_type'].eql?('no_permission') }
-
-            unless no_permissions.empty?
-              errors << "\n\nYou do not have (R) permissions for modules:\n\n"
-              no_permissions.each { |np| errors << "  - #{np['module_namespace']}:#{np['module_name']} (owner: #{np['module_owner']})\n" }
-              errors << "\nPlease contact owner(s) to change permissions for those modules."
-            end
-          end
-
-          raise DtkError, errors unless errors.empty?
-        end
-
-        # check if all dependent modules are frozen; if they are don't display prompt for update
-        def check_for_frozen_modules(required_modules)
-          return true if required_modules.nil? || required_modules.empty?
-
-          modules_to_update = required_modules.select{ |md| (md['frozen'].nil? || md['frozen'] == false)}
-          return modules_to_update.empty?
-        end
-
-        def module_ref_content(location)
-          abs_location = File.join(location, MODULE_REF_FILE)
-          File.exists?(abs_location) ? File.read(abs_location) : nil
-        end
-
-        private
-
-        def print_out(message, color=:yellow)
-          DTK::Client::OsUtil.print(message, color)
-        end
-      end
-    end
-  end
-end

data/lib/util/ssh_util.rb

@@ -1,94 +0,0 @@
-#
-# 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
-  module Client
-    module SSHUtil
-
-      def self.read_and_validate_pub_key(path_to_pub_key)
-        is_ssh_key_path_valid?(path_to_pub_key)
-        rsa_pub_key = File.open(path_to_pub_key) { |f| f.read }
-        is_ssh_key_content_valid?(rsa_pub_key)
-        rsa_pub_key
-      end
-
-      def self.update_ssh_known_hosts(server_dns,server_fingerprint)
-        known_hosts_path = ssh_known_hosts_path()
-        if File.file?(known_hosts_path)
-          `ssh-keygen -f #{known_hosts_path} -R #{server_dns} 2> /dev/null`
-          File.open(known_hosts_path,"a"){|f|f << server_fingerprint}
-        else
-          ssh_base_dir = ssh_base_dir()
-          unless File.directory?(ssh_base_dir)
-            Dir.mkdir(ssh_base_dir)
-          end
-          File.open(known_hosts_path,"w"){|f|f << server_fingerprint}
-        end
-      end
-      
-      def self.default_rsa_pub_key_path()
-        "#{ssh_base_dir()}/id_rsa.pub"
-      end
-
-      def self.rsa_pub_key_content()
-        path_to_key = self.default_rsa_pub_key_path()
-        unless File.file?(path_to_key)
-          raise DtkError,"No File found at (#{path_to_key}). Path is wrong or it is necessary to generate the public rsa key (e.g., run ssh-keygen -t rsa)"
-        end
-
-        content = File.open(path_to_key){ |f| f.read }
-        content.chomp
-      end
-
-      def self.ssh_reachable?(user, server, timeout = 3)
-        output = `ssh -o ConnectTimeout=#{timeout} -o \"StrictHostKeyChecking no\" -o \"UserKnownHostsFile /dev/null\" -q #{user}@#{server} exit; echo $?`
-
-        # if response 0 than it is able to connect
-        "0".eql?(output.strip())
-      end
-
-
-    private
-
-      def self.ssh_base_dir()
-        "#{OsUtil.dtk_home_dir}/.ssh"
-      end
-      
-      def self.ssh_known_hosts_path()
-        "#{ssh_base_dir()}/known_hosts"
-      end
-
-      def self.is_ssh_key_path_valid?(path_to_key)
-        unless path_to_key.include?(".pub")
-          raise DtkError, "[ERROR] Invalid public key file path (#{path_to_key}). Please provide valid path and try again."
-        end
-
-        unless File.exists?(path_to_key)
-          raise DtkError, "[ERROR] Not able to find provided key (#{path_to_key}). Please provide valid path and try again."
-        end
-      end
-
-      def self.is_ssh_key_content_valid?(rsa_pub_key)
-        # checking know ssh rsa pub key content
-        if(rsa_pub_key.empty? || !rsa_pub_key.include?("AAAAB3NzaC1yc2EA"))
-          raise DtkError, "[ERROR] SSH public key (#{path_to_key}) does not have valid content. Please check your key and try again."
-        end
-      end
-
-    end
-  end
-end