dtk-client 0.9.1 → 0.10.0

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

@@ -1,53 +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::Client
-  module NodeMixin
-    def get_node_info_for_ssh_login(node_id, context_params)
-      context_params.forward_options(:json_return => true)
-      response = info_aux(context_params)
-      return response unless response.ok?
-      # Should only have info about the specfic node_id
-      
-      unless node_info = response.data(:nodes).find{ |node| node_id == (node['node_properties'] || {})['node_id'] }
-        raise DtkError, "Cannot find info about node with id '#{node_id}'"
-      end
-
-      data = {}
-      node_properties = node_info['node_properties'] || {}
-      if public_dns = node_properties['ec2_public_address']
-        data.merge!('public_dns' => public_dns)
-      end
-      if default_login_user = NodeMixin.default_login_user?(node_properties)
-        data.merge!('default_login_user' => default_login_user)
-      end
-
-      Response::Ok.new(data)
-    end
-
-    def self.default_login_user?(node_properties)
-    if os_type = node_properties['os_type']
-        DefaultLoginByOSType[os_type]
-      end
-    end
-
-    DefaultLoginByOSType = {
-      'ubuntu'       => 'ubuntu',
-      'amazon-linux' => 'ec2-user'
-    }
-  end
-end

data/lib/commands/common/thor/poller.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.
-#
-module DTK::Client
-  module Poller
-
-    PERIOD_WAIT_TIME = 1
-
-    def poller_response(wait_time = PERIOD_WAIT_TIME)
-      begin
-        response = nil
-        thread   = Thread.new(self) do |main_thread|
-          begin
-            while true
-              messages_response = main_thread.get main_thread.rest_url("messages/retrieve")
-              print_response(messages_response.data) if messages_response.ok?
-              sleep(wait_time)
-            end
-          rescue => e
-            puts e.message
-            pp e.backtrace
-          end
-        end
-
-        response = yield
-      ensure
-        thread.kill
-      end
-      response
-    end
-
-    def print_response(message_array)
-      message_array.each do |msg|
-        DTK::Client::OsUtil.print(msg['message'], resolve_type(msg['type']))
-      end
-    end
-
-    def resolve_type(message_type)
-      case message_type.to_sym
-      when :info
-        :white
-      when :warning
-        :yellow
-      when :error
-        :red
-      else
-        :white
-      end
-    end
-  end
-end

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

@@ -1,152 +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::Client
-  module PullFromRemoteMixin
-    def pull_from_remote_aux(module_type,module_id,opts={})
-      version = opts[:version]
-      remote_namespace = opts[:remote_namespace]
-      #get remote module info, errors raised if remote is not linked or access errors
-      path_to_key = SSHUtil.default_rsa_pub_key_path()
-      rsa_pub_key = File.file?(path_to_key) && File.open(path_to_key){|f|f.read}.chomp
-
-      post_body = PostBody.new(
-        PullFromRemote.id_field(module_type) => module_id,
-        :access_rights => "r",
-        :action => "pull",
-        :version? => version,
-        :remote_namespace? => remote_namespace,
-        :rsa_pub_key? => rsa_pub_key
-      )
-      response = post(rest_url("#{module_type}/get_remote_module_info"),post_body)
-      return response unless response.ok?
-
-      module_name,full_module_name, frozen = response.data(:module_name, :full_module_name, :frozen)
-      raise DtkError, "You are not allowed to update frozen #{module_type} versions!" if frozen
-
-      remote_params = response.data_hash_form(:remote_repo_url,:remote_repo,:remote_branch)
-      remote_params.merge!(:version => version) if version
-
-      # check and import component module dependencies before importing service itself
-      unless opts[:skip_recursive_pull]
-        import_module_component_dependencies(module_type, module_id, remote_namespace)
-      end
-
-      # check whether a local module exists to determine whether pull from local clone or try to pull from server
-      # TODO: probably remove OsUtil.print("Pulling changes from remote: #{remote_params[:remote_repo]} @ #{remote_params[:remote_repo_url]}")
-
-      if Helper(:git_repo).local_clone_dir_exists?(module_type, module_name, :full_module_name => full_module_name, :version => version)
-        unless rsa_pub_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
-        opts_perform_locally = remote_params.merge(
-          :full_module_name => full_module_name,
-          :force => opts[:force],
-          :do_not_raise => opts[:do_not_raise],
-          :ignore_dependency_merge_conflict => opts[:ignore_dependency_merge_conflict]
-        )
-        PullFromRemote.perform_locally(self,module_type,module_id,module_name,opts_perform_locally)
-      else
-        # TODO: see if this works correctly
-        PullFromRemote.perform_on_server(self,module_type,module_id,full_module_name,remote_params)
-      end
-    end
-
-   private
-
-    ##
-    #
-    # module_type: will be :component_module or :service_module
-    def import_module_component_dependencies(module_type, module_id, remote_namespace = nil)
-      response = resolve_pull_from_remote_on_server(module_type, module_id, remote_namespace)
-
-      print "Resolving dependencies please wait ... "
-      RemoteDependencyUtil.check_permission_warnings(response)
-
-      # install them all!
-      if (response.ok? && !(missing_components = response.data(:missing_modules)).empty?)
-        required_modules = response.data(:required_modules)
-        puts " New dependencies found, Installing."
-
-        trigger_module_auto_import(missing_components, required_modules, { :include_pull_action => true })
-
-        puts "Resuming pull from remote ..."
-      else
-        puts 'Done.'
-      end
-
-      # pull them all!
-      if (response.ok? && !(required_modules = response.data(:required_modules)).empty?)
-        trigger_module_auto_pull(required_modules)
-      end
-
-      RemoteDependencyUtil.print_dependency_warnings(response)
-      nil
-    end
-
-  private
-
-    def resolve_pull_from_remote_on_server(module_type, module_id, remote_namespace=nil)
-      post_body = PostBody.new(
-        :module_id => module_id,
-        :remote_namespace? => remote_namespace,
-        :rsa_pub_key => SSHUtil.rsa_pub_key_content()
-      )
-      post(rest_url("#{module_type}/resolve_pull_from_remote"),post_body)
-    end
-
-    module PullFromRemote
-      extend CommandBase
-      def self.perform_locally(cmd_obj,module_type,module_id,module_name,remote_params)
-        opts = remote_params
-        response = cmd_obj.Helper(:git_repo).pull_changes(module_type,module_name,opts)
-
-        # return response unless response.ok?
-        if custom_message = response.data[:custom_message]
-          puts custom_message
-        elsif (response.data[:diffs].nil? || response.data[:diffs].empty?)
-          puts "No changes to pull from remote.".colorize(:yellow) unless response['errors']
-        else
-          puts "Changes pulled from remote".colorize(:green)
-        end
-
-        response
-      end
-
-      def self.perform_on_server(cmd_obj,module_type,module_id,module_name,remote_params)
-        #TODO: this does not handle different namespaces; so suggesting workaround for now
-        raise DtkError, "Module must be cloned to perform this operation; execute 'clone' command and then retry."
-        post_body = {
-          id_field(module_type) => module_id,
-          :remote_repo => remote_params[:remote_repo],
-          :module_name => module_name
-        }
-        post_body.merge!(:version => remote_params[:version]) if remote_params[:version]
-        response = post rest_url("#{module_type}/pull_from_remote"), post_body
-
-
-        puts "You have successfully pulled code on server instance." if response.ok?
-        response
-      end
-
-      def self.id_field(module_type)
-        "#{module_type}_id"
-      end
-
-    end
-  end
-end

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

@@ -1,72 +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::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

@@ -1,101 +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::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

@@ -1,162 +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_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