dtk-node-agent 0.7.7 → 0.8.0

data/mcollective_additions/plugins/v2.2/agent/discovery.rb

@@ -1,39 +0,0 @@
-module MCollective
-  module Agent
-    # Discovery agent for The Marionette Collective
-    #
-    # Released under the Apache License, Version 2
-    class Discovery
-      attr_reader :timeout, :meta
-
-      def initialize
-        config = Config.instance.pluginconf
-
-        @timeout = 5
-        @timeout = config["discovery.timeout"].to_i if config.include?("discovery.timeout")
-
-        @meta = {:license => "Apache License, Version 2",
-                 :author => "R.I.Pienaar <rip@devco.net>",
-                 :timeout => @timeout,
-                 :name => "Discovery Agent",
-                 :version => MCollective.version,
-                 :url => "http://www.marionette-collective.org",
-                 :description => "MCollective Discovery Agent"}
-      end
-
-      def handlemsg(msg, stomp)
-        reply = "unknown request"
-
-        case msg[:body]
-          when "ping"
-            reply = "pong"
-
-          else
-            reply = "Unknown Request: #{msg[:body]}"
-        end
-
-        reply
-      end
-    end
-  end
-end

data/mcollective_additions/plugins/v2.2/agent/dtk_node_agent_git_client.rb

@@ -1,94 +0,0 @@
-require 'grit'
-module DTK
-  module NodeAgent
-    class GitClient
-      def initialize(repo_dir,opts={})
-        @repo_dir = repo_dir
-        @grit_repo = (opts[:create] ? ::Grit::Repo.init(repo_dir) : ::Grit::Repo.new(repo_dir)) 
-      end
-      
-      def clone_branch(remote_repo,branch,opts={})
-        git_command__remote_add(remote_repo,branch)
-        git_command__checkout(opts[:sha]||branch)
-      end
-      
-      def pull_and_checkout_branch?(branch,opts={})
-        sha = opts[:sha]
-        #shortcut
-        return if sha and (sha == current_branch_or_head())
-
-        unless remote_branch_exists?(branch)
-          git_command__remote_branch_add(branch)
-          git_command__fetch()
-        end
-
-        if branch_exists?(branch)
-          git_command__pull(branch)
-          git_command__checkout(sha) if sha
-        else
-          git_command__checkout(sha||branch)
-        end
-      end
-
-    private
-      def git_command__remote_add(remote_repo,branch,remote_name=nil)
-        remote_name ||= default_remote()
-        git_command().remote(git_command_opts(),"add","-t", branch, "-f", remote_name, remote_repo)
-      end
-
-      def git_command__remote_branch_add(branch,remote_name=nil)
-        remote_name ||= default_remote()
-        git_command().remote(git_command_opts(),"set-branches", "--add", remote_name, branch)
-      end
-      
-      def git_command__checkout(ref)
-        unless current_branch_or_head() == ref
-          git_command().checkout(git_command_opts(),ref)
-        end
-      end
-      
-      def git_command__fetch(remote_name=nil)
-        remote_name ||= default_remote()
-        git_command().fetch(git_command_opts(),remote_name)
-      end
-
-      def git_command__pull(branch,remote_name=nil)
-        remote_name ||= default_remote()
-        git_command().pull(git_command_opts(),remote_name,branch)
-      end
-
-      def branch_exists?(branch)
-        @grit_repo.heads.find{|h|h.name == branch} ? true : nil
-      end
-
-      def remote_branch_exists?(branch,remote_name=nil)
-        remote_name ||= default_remote()
-        remote_branch = "#{remote_name}/#{branch}"
-        @grit_repo.remotes.find{|h|h.name == remote_branch} ? true : nil
-      end
-      
-      def current_branch_or_head()
-        #this returns sha when detached head
-        if @grit_repo.head
-          @grit_repo.head.name
-        elsif @grit_repo.commit('HEAD')
-          @grit_repo.commit('HEAD').id
-        end
-      end
-
-      def default_remote()
-        'origin'
-      end
-
-      def git_command_opts(opts={})
-        ret = {:raise => true, :timeout => 60}
-        ret.merge!(:chdir => @repo_dir) unless opts[:no_chdir]
-      end
-
-      def git_command()
-        @grit_repo.git
-      end
-    end
-  end
-end
-

data/mcollective_additions/plugins/v2.2/agent/execute_tests.ddl

@@ -1,9 +0,0 @@
-metadata    :name        => "component module tests executor",
-            :description => "Agent to executing component module infrastructure tests",
-            :author      => "Reactor8",
-            :license     => "",
-            :version     => "",
-            :url         => "",
-            :timeout     => 10
-action "execute_tests", :description => "execute all component module infrastructure tests" do
-end

data/mcollective_additions/plugins/v2.2/agent/execute_tests.rb

@@ -1,111 +0,0 @@
-module MCollective
-  module Agent
-    class Execute_tests < RPC::Agent
-      def initialize()
-        super()
-        @log = Log.instance
-      end
-
-      def pull_modules(module_version_context, git_server)
-        ENV['GIT_SHELL'] = nil #This is put in because if vcsrepo Puppet module used it sets this
-        begin
-          repo_dir = "#{ModulePath}/#{module_version_context[:implementation]}"
-          remote_repo = "#{git_server}:#{module_version_context[:repo]}"
-          opts = Hash.new
-          begin
-            if File.exists?(repo_dir)
-              @log.info("Branch already exists. Checkout to branch and pull latest changes...")
-              git_repo = ::DTK::NodeAgent::GitClient.new(repo_dir)
-              git_repo.pull_and_checkout_branch?(module_version_context[:branch],opts)
-            else
-              @log.info("Branch does not exist. Cloning branch...")
-              git_repo = ::DTK::NodeAgent::GitClient.new(repo_dir,:create=>true)
-              git_repo.clone_branch(remote_repo,module_version_context[:branch],opts)
-            end
-          rescue Exception => e
-            log_error(e)
-            #to achieve idempotent behavior; fully remove directory if any problems
-            FileUtils.rm_rf repo_dir
-            raise e
-          end
-        rescue Exception => e
-          log_error(e)
-        end
-      end
-
-      def log_error(e)
-        log_error = ([e.inspect]+backtrace_subset(e)).join("\n")
-        @log.info("\n----------------error-----\n#{log_error}\n----------------error-----")
-      end
-
-      action "execute_tests" do
-        #Get list of component modules that have spec tests
-        list_output=`ls /etc/puppet/modules/*/dtk/serverspec/spec/localhost/*/*_spec.rb`
-        regex_pattern=/modules\/(.+)\/dtk\/serverspec\/spec\/localhost\/(.+)\//
-        ModuleInfo = Struct.new(:module_name, :component_name, :full_component_name)
-        modules_info = []
-
-        components = []
-        #Strip away node part (/)...leave only part which represent full component name
-        request[:components].each do |c|
-          if c.include? "/"
-            components << c.split("/").last
-          else
-            components << c
-          end
-        end
-
-        list_output.each do |line|
-          match = line.match(regex_pattern)
-          components.each do |c|
-            if c.include? "::"
-              stripped_c = c.split("::").last
-              modules_info << ModuleInfo.new(match[1],match[2],c) if stripped_c.eql? match[2]
-            elsif c.eql? match[2]
-              modules_info << ModuleInfo.new(match[1],match[2],c)
-            end
-          end
-        end
-
-        all_spec_results = []
-        #filter out redundant module info if any
-        modules_info = modules_info.uniq
-        #Pull latest changes for modules if any
-        git_server = Facts["git-server"]
-
-        begin
-          modules_info.each do |module_info|
-            component_module = module_info[:module_name]
-            component_name = module_info[:component_name]
-            full_component_name = module_info[:full_component_name]
-            #Filter out version context for modules that don't exist on node
-            filtered_version_context = request[:version_context].select { |x| x[:implementation] == module_info[:module_name] }.first
-            pull_modules(filtered_version_context,git_server)
-
-            @log.info("Executing serverspec test: /etc/puppet/modules/#{component_module}/dtk/serverspec/spec/localhost/#{component_name}/*_spec.rb")
-            spec_results=`/opt/puppet-omnibus/embedded/bin/rspec /etc/puppet/modules/#{component_module}/dtk/serverspec/spec/localhost/#{component_name}/*_spec.rb --format j 2>&1`
-            raise spec_results unless spec_results_json = JSON.parse(spec_results)
-
-            spec_results_json['examples'].each do |spec|
-              spec_result = {}
-              spec_result.store(:module_name, component_module)
-              spec_result.store(:component_name, full_component_name)
-              spec_result.store(:test_result, spec['full_description'])
-              spec_result.store(:status, spec['status'])
-              all_spec_results << spec_result
-            end
-          end
-          reply[:data] = all_spec_results
-          reply[:pbuilderid] = Facts["pbuilderid"]
-          reply[:status] = :ok
-        rescue Exception => e
-          @log.info("Error while executing serverspec test")
-          @log.info(e.message)
-          reply[:data] = { :test_error => "#{e.message.lines.first}" }
-          reply[:pbuilderid] = Facts["pbuilderid"]
-          reply[:status] = :notok
-        end
-      end
-    end
-  end
-end

data/mcollective_additions/plugins/v2.2/agent/execute_tests_v2.ddl

@@ -1,9 +0,0 @@
-metadata    :name        => "component module tests executor v2",
-            :description => "Agent to executing component module infrastructure tests v2",
-            :author      => "Reactor8",
-            :license     => "",
-            :version     => "",
-            :url         => "",
-            :timeout     => 10
-action "execute_tests_v2", :description => "execute all component module infrastructure tests v2" do
-end

data/mcollective_additions/plugins/v2.2/agent/execute_tests_v2.rb

@@ -1,131 +0,0 @@
-require 'rspec'
-require 'rspec/core'
-require 'rspec/core/formatters/json_formatter'
-require 'json'
-
-ModulePath = "/etc/puppet/modules"
-ServerspecPath = "serverspec/spec/localhost"
-
-module MCollective
-  module Agent
-    class ServerSpecHelper
-      def execute(spec_path, vars=[])
-        vars.each do |var|
-          var.each_pair do |k,v|
-            Thread.current[k] = v
-          end
-        end
-
-        config = RSpec.configuration
-        json_formatter = RSpec::Core::Formatters::JsonFormatter.new(config.output)
-        reporter =  RSpec::Core::Reporter.new(json_formatter)
-        config.instance_variable_set(:@reporter, reporter)
-        begin
-          ::RSpec::Core::Runner.run([spec_path,'--format','j'])
-          json_formatter.output_hash
-        rescue Exception => e
-          return e.message
-        end
-      end
-    end
-
-    class Execute_tests_v2 < RPC::Agent
-      def initialize()
-        super()
-        @log = Log.instance
-      end
-
-      def pull_modules(module_version_context, git_server)
-        ENV['GIT_SHELL'] = nil #This is put in because if vcsrepo Puppet module used it sets this
-        begin
-          repo_dir = "#{ModulePath}/#{module_version_context[:implementation]}"
-          remote_repo = "#{git_server}:#{module_version_context[:repo]}"
-          opts = Hash.new
-          begin
-            if File.exists?(repo_dir)
-              @log.info("Branch already exists. Checkout to branch and pull latest changes...")
-              git_repo = ::DTK::NodeAgent::GitClient.new(repo_dir)
-              git_repo.pull_and_checkout_branch?(module_version_context[:branch],opts)
-            else
-              @log.info("Branch does not exist. Cloning branch...")
-              git_repo = ::DTK::NodeAgent::GitClient.new(repo_dir,:create=>true)
-              git_repo.clone_branch(remote_repo,module_version_context[:branch],opts)
-            end
-          rescue Exception => e
-            log_error(e)
-            #to achieve idempotent behavior; fully remove directory if any problems
-            FileUtils.rm_rf repo_dir
-            raise e
-          end
-        rescue Exception => e
-          log_error(e)
-        end
-      end
-
-      def log_error(e)
-        log_error = ([e.inspect]+e.backtrace).join("\n")
-        @log.info("\n----------------error-----\n#{log_error}\n----------------error-----")
-      end
-
-      action "execute_tests_v2" do
-        spec_helper = ServerSpecHelper.new
-        all_spec_results = []
-
-        #Pull latest changes for modules if any
-        git_server = Facts["git-server"]
-
-        request[:components].each do |component|
-          #Filter version context for modules that exist on node
-          filtered_version_context = request[:version_context].select { |x| x[:implementation] == component[:module_name] }.first
-          pull_modules(filtered_version_context,git_server)
-
-          component_name = ""
-          if component[:component].include? "/"
-            component_name = component[:component].split("/").last
-          else
-            component_name = component[:component]
-          end
-
-          #all_tests needs to be calculated after the pull module done
-          all_tests = Dir["#{ModulePath}/*/#{ServerspecPath}/*.rb"]
-          test = all_tests.select { |test| (test.include? component[:test_name]) && (test.include? component[:module_name]) }
-          @log.info("Executing serverspec test: #{test.first}")
-          spec_results = spec_helper.execute(test.first, component[:params])
-          @log.info("Serverspec results: #{spec_results}")
-
-          if spec_results.is_a?(Hash)
-            spec_results[:examples].each do |spec|
-              spec_result = {}
-              spec_result.store(:module_name, component[:module_name])
-              spec_result.store(:component_name, component_name)
-              spec_result.store(:test_component_name, component[:test_component])
-              spec_result.store(:test_name, component[:test_name])
-              spec_result.store(:test_result, spec[:full_description])
-              spec_result.store(:status, spec[:status])
-
-              if spec[:status].include? "failed"
-                backtrace = spec[:exception][:backtrace].find { |x| x.include? component[:module_name] }
-                error = backtrace + " " + spec[:exception][:class] + ": " + spec[:exception][:message]
-                spec_result.store(:test_error, error)
-              end
-              all_spec_results << spec_result
-            end
-          else
-            spec_result = {}
-            spec_result.store(:module_name, component[:module_name])
-            spec_result.store(:component_name, component_name)
-            spec_result.store(:test_component_name, component[:test_component])
-            spec_result.store(:test_name, component[:test_name])
-            spec_result.store(:test_result, "N/A")
-            spec_result.store(:status, "failed")
-            spec_result.store(:test_error, spec_results)
-            all_spec_results << spec_result
-          end
-        end
-        reply[:data] = all_spec_results
-        reply[:pbuilderid] = Facts["pbuilderid"]
-        reply[:status] = :ok
-      end
-    end
-  end
-end

data/mcollective_additions/plugins/v2.2/agent/get_log_fragment.ddl

@@ -1,15 +0,0 @@
-metadata    :name        => "get log fragment",
-                        :description => "get log fragment",
-                        :author      => "Reactor8",
-                        :license     => "",
-                        :version     => "",
-                        :url         => "",
-                        :timeout     => 20
-action "get", :description => "get log data fragment" do
-  display :always
-  %w{status error data pbuilderid}.each do |k|
-    output k.to_sym,
-      :description => k.capitalize,
-      :display_as => k.capitalize
-  end		
-end

data/mcollective_additions/plugins/v2.2/agent/get_log_fragment.rb

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-
-module MCollective
-  #TODO: shoudl go in common area
-  LogFileHandles = {:task_id => Hash.new, :top_task_id => Hash.new}
-
-  module Agent
-    class Get_log_fragment < RPC::Agent
-            metadata    :name        => "get log fragment",
-                        :description => "get log fragment",
-                        :author      => "Reactor8",
-                        :license     => "",
-                        :version     => "",
-                        :url         => "",
-                        :timeout     => 20
-      def initialize()
-        super()
-        @log = Log.instance
-      end
-      def get_action()
-        validate :key, String
-        validate :value, String
-        log_file_dir = "/var/log/puppet" 
-        key = request[:key]
-        value = request[:value]
-        lines = get_log_fragment(log_file_dir,key,value)
-        pbuilderid = Facts["pbuilderid"]
-        if lines.nil?
-          error_msg = "Cannot find log fragment matching #{key}=#{value}"
-          error_response = {
-            :status => :failed, 
-            :error => {
-              :message => error_msg
-            },
-            :pbuilderid => pbuilderid
-          }
-          @log.error(error_msg)
-          reply.data = error_response
-        else
-          ok_response = {
-            :status => :ok,
-            :data => lines,
-            :pbuilderid => pbuilderid
-          }
-          reply.data = ok_response
-        end
-      end
-     private
-      def get_log_fragment(log_file_dir,key,value)
-        #flush file if it is open
-        if file_handle = (LogFileHandles[key.to_sym]||{})[value]
-          file_handle.flush
-        end
- 
-        delim = key.to_sym == :top_task_id ? "\\." : ":"
-        string_key = "#{key}:#{value.to_s}#{delim}"
-        ret = Array.new
-        matches = Dir["#{log_file_dir}/*.log"].grep(Regexp.new(string_key))
-        if matches.size == 0
-          return nil
-        end
-        matching_file = matches.size == 1 ?
-          matches.first :
-          #this finds teh most recent file
-          matches.map{|file|[file,File.mtime(file)]}.sort{|a,b|b[1]<=>a[1]}.first[0]
-        begin
-          f = File.open(matching_file)
-          until f.eof
-            ret << f.readline.chop
-          end
-        ensure
-          f.close
-        end
-        ret
-      end
-    end
-  end
-end