dtk-client 0.5.6.1

data/lib/command_helpers/jenkins_client.rb

@@ -0,0 +1,91 @@
+require 'jenkins-client' 
+module DTK; module Client
+  class JenkinsClient
+    require File.expand_path('jenkins_client/config_xml', File.dirname(__FILE__))
+
+    def self.create_service_module_project(module_id,module_name,repo_url,branch)
+      jenkins_project_name = module_name
+      config_xml_contents = ConfigXML.generate_service_module_project(repo_url,module_id,branch)
+      connection().create_job(jenkins_project_name,config_xml_contents)
+    end
+
+    def self.create_service_module_project?(module_id,module_name,repo_url,branch)
+      jenkins_project_name = module_name
+      jobs = get_jobs()||[]
+      #no op if job exists already
+      unless jobs.find{|j|j["name"] == jenkins_project_name}
+        create_service_module_project(module_id,module_name,repo_url,branch)
+      end
+    end
+
+    def self.create_assembly_project(assembly_name,assembly_id)
+      jenkins_project_name = assembly_name.gsub(/::/,"-")
+      config_xml_contents = ConfigXML.generate_assembly_project(assembly_id)
+      connection().create_job(jenkins_project_name,config_xml_contents)
+    end
+
+    def self.create_assembly_project?(assembly_name,assembly_id)
+      jenkins_project_name = assembly_name.gsub(/::/,"-")
+      jobs = get_jobs()||[]
+      #no op if job exists already
+      unless jobs.find{|j|j["name"] == jenkins_project_name}
+        create_assembly_project(assembly_name,assembly_id)
+      end
+    end
+
+    def self.get_jobs()
+      connection().get_jobs()
+    end
+
+   private
+    def self.connection()
+      return @connection if @connection
+      #TODO: hardwired
+      connection_hash = {
+        :username => "rich",
+        :password => "test",
+        :url => "http://ec2-107-22-254-226.compute-1.amazonaws.com:8080"
+      }
+      @connection = Connection.new(connection_hash)
+    end
+
+    class Connection < Hash
+      def initialize(connection_hash)
+        super()
+        merge!(connection_hash)
+        set_connection()
+      end
+      def create_job(job_name,config_xml_contents)
+        ::Jenkins::Client::Job.create(job_name, config_xml_contents)
+      end
+    
+      def get_info()
+        get('api/json')
+      end
+
+      def get_jobs()
+        get_info()["jobs"]
+      end
+     private
+      #TODO: one issue with the jenkins-client adapter is that it a singleton and thus only allows connection under one user to one jenkins server
+      def set_connection()
+        ::Jenkins::Client.configure do |c|
+          c.username = self[:username]
+          c.password = self[:password]
+          c.url = self[:url]
+        end
+      end
+
+      def get(path)
+        faraday_response = ::Jenkins::Client.get(path)
+        unless [200].include?(faraday_response.status)
+          raise Error.new("Bad response from Jenkins (status = #{faraday_response.status.to_s})")
+        end
+        faraday_response.body
+      end
+    end
+  end
+end; end
+ 
+
+

data/lib/command_helpers/service_importer.rb

@@ -0,0 +1,99 @@
+dtk_require_from_base('configurator')
+module DTK::Client
+  #
+  # Main purpose of this module is to recognize which local modules are missing based on 
+  # name, namespace, version and for those missing component module module will call
+  # module#clone and module#import_dtkn method to get missing component modules 
+  #
+  module ServiceImporter
+    def create_missing_clone_dirs()
+      ::DTK::Client::Configurator.create_missing_clone_dirs
+    end
+
+    def self.error_message(name, errors)
+      #TODO: it is contingent whether solution is to fix errors using 'edit' command
+      "Module '#{name}' has errors:\n  #{errors.to_s}\nYou can fix errors in the DSL by invoking the 'edit' command.\n"
+    end
+
+    ##
+    # Method will trigger import for each missing module component
+    #
+    def trigger_module_component_import(missing_component_list,opts={})      
+      puts "Auto-importing missing component module(s)"
+
+      missing_component_list.each do |m_module|
+        print "Importing component module '#{m_module['name']}' ... "
+        module_name = "#{m_module['namespace']}/#{m_module['name']}"
+        module_name += "/#{m_module['version']}" if m_module['version']
+        new_context_params = ::DTK::Shell::ContextParams.new([module_name])
+        new_context_params.override_method_argument!('option_2', m_module['version'])
+        new_context_params.forward_options( { "skip_cloning" => true}).merge!(opts)
+
+        response = ContextRouter.routeTask("component_module", "install", new_context_params, @conn)
+        puts(response.data(:does_not_exist) ? response.data(:does_not_exist) : "Done.")
+        raise DTK::Client::DtkError, response.error_message unless response.ok?        
+      end
+      
+      Response::Ok.new()
+    end
+
+    def resolve_missing_components(service_module_id, service_module_name, namespace_to_use, force_clone=false)
+      # Get dependency component modules and cross reference them with local component modules
+      module_component_list = post rest_url("service_module/list_component_modules"), { :service_module_id => service_module_id }
+      local_modules, needed_modules = OsUtil.local_component_module_list(), Array.new
+
+      module_component_list.data.each do |dependency_module|
+        unless local_modules.include?(formated_name = formulate_module_name(dependency_module['display_name'], dependency_module['version']))
+          needed_modules << dependency_module.merge({'formated_name' => formated_name})
+        end
+      end
+
+      unless needed_modules.empty?
+        puts "Service '#{service_module_name}' has following dependencies: \n\n"
+        needed_modules.each { |m| puts " - #{m['formated_name']}" }
+        is_install_dependencies = true
+        is_install_dependencies = Console.confirmation_prompt("\nDo you want to clone missing component module dependencies") unless force_clone
+
+        # we get list of modules available on server
+
+        new_context_params = nil
+
+        if is_install_dependencies
+          needed_modules.each do |m|
+            formated_name = m['formated_name']
+            print "Cloning component module '#{formated_name}' from server ... "
+            thor_options = {}
+            thor_options["version"] = m['version']
+            thor_options["skip_edit"] = true
+            thor_options["omit_output"] = true
+            new_context_params = ::DTK::Shell::ContextParams.new
+            new_context_params.forward_options(thor_options)
+            new_context_params.add_context_to_params(formated_name, :"component-module", m['id'])             
+            response = ContextRouter.routeTask("component_module", "clone", new_context_params, @conn)
+            puts "Done."
+          end
+        end
+      end
+    end
+
+    private
+    #
+    # As the result we can have multiple version so we need to resolve them
+    #
+    # Returns: Array<String>
+    def resolve_module_names(e)
+      versions = (e['version'] ? e['version'].split(',') : ['CURRENT'])
+
+      versions.collect { |version| formulate_module_name(e['display_name'], version)}
+    end
+
+    # Resolves local module name
+    #
+    # Returns: String
+    def formulate_module_name(display_name, version)
+      version = nil if 'CURRENT'.eql?(version)
+      (version ? "#{display_name}-#{version.strip}" : "#{display_name}")
+    end
+
+  end
+end

data/lib/command_helpers/service_link.rb

@@ -0,0 +1,18 @@
+module DTK; module Client; class CommandHelper
+  class ServiceLink < self; class << self
+    def post_body_with_id_keys(context_params,method_argument_names)
+      assembly_or_workspace_id = context_params.retrieve_arguments([[:service_id!,:workspace_id!]])
+      ret = {:assembly_id => assembly_or_workspace_id}
+      if context_params.is_last_command_eql_to?(:component)
+        component_id,service_type = context_params.retrieve_arguments([:component_id!,:option_1!],method_argument_names)
+        ret.merge(:input_component_id => component_id,:service_type => service_type)
+      else
+        service_link_id = context_params.retrieve_arguments([:option_1!],method_argument_names)
+        ret.merge(:service_link_id => service_link_id)
+      end
+    end
+
+  end; end
+end; end; end
+
+

data/lib/command_helpers/ssh_processing.rb

@@ -0,0 +1,43 @@
+module DTK; module Client
+  class SshProcessing
+    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}`
+        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
+
+
+   private
+    def self.ssh_base_dir()
+      "#{ENV['HOME']}/.ssh" #TODO: very brittle
+    end
+    
+    def self.ssh_known_hosts_path()
+      "#{ssh_base_dir()}/known_hosts"
+    end
+  end
+end; end
+ 
+
+