dtk-node-agent 0.5.10

data/mcollective_additions/plugins/v1.2/agent/git_access.ddl

@@ -0,0 +1,9 @@
+metadata    :name        => "git access",
+            :description => "Agent to enable git access",
+            :author      => "Reactor8",
+            :license     => "",
+            :version     => "",
+            :url         => "",
+            :timeout     => 20
+action "add_rsa_info", :description => "add ssh rsa info" do
+end

data/mcollective_additions/plugins/v1.2/agent/git_access.rb

@@ -0,0 +1,79 @@
+module MCollective
+  module Agent
+    class Git_access < RPC::Agent
+      metadata    :name        => "git access",
+                  :description => "Agent to enable git access",
+                  :author      => "Reactor8",
+                  :license     => "",
+                  :version     => "",
+                  :url         => "",
+                  :timeout     => 20
+      action "add_rsa_info" do 
+        ssh_folder_path = '/root/.ssh'
+        rsa_path     = "#{ssh_folder_path}/id_rsa"
+        rsa_pub_path = "#{ssh_folder_path}/id_rsa.pub"
+        known_hosts  = "#{ssh_folder_path}/known_hosts"
+
+        begin
+          # validate request
+          validate_request(request)
+
+          #create private rsa file if needed
+          unless donot_create_file?(:private,rsa_path,request[:agent_ssh_key_private])
+            File.open(rsa_path,"w",0600){|f|f.print request[:agent_ssh_key_private]}
+          end
+
+          #create public rsa file if needed
+          unless donot_create_file?(:public,rsa_pub_path,request[:agent_ssh_key_public])
+            File.open(rsa_pub_path,"w"){|f|f.print request[:agent_ssh_key_public]}
+          end
+
+          #create or append if key not there
+          skip = nil
+          fp = request[:server_ssh_rsa_fingerprint]
+          if File.exists?(known_hosts)
+            fp_key = (fp =~ Regexp.new("^[|]1[|]([^=]+)=");$1)
+            if fp_key
+              fp_key_regexp =  Regexp.new("^.1.#{fp_key}")
+              skip = !!File.open(known_hosts){|f|f.find{|line|line =~ fp_key_regexp}} 
+            end
+          end
+          unless skip
+            File.open(known_hosts,"a"){|f|f.print request[:server_ssh_rsa_fingerprint]}
+          end
+
+          reply.data   = { :status => :succeeded}
+         rescue Exception => e
+          reply.data   = { :status => :failed, :error => {:message => e.message}}
+        end
+      end
+
+      #TODO: move to using mcollective vallidation on ddl
+      def validate_request(req)
+        required_params = [:agent_ssh_key_public, :agent_ssh_key_private, :server_ssh_rsa_fingerprint]
+        missing_params  = []
+        required_params.each do |param|
+          missing_params << param if req[param].nil?
+        end
+
+        unless missing_params.empty?
+          raise "Request is missing required param(s): #{missing_params.join(',')} please review your request."
+        end
+      end
+
+      def donot_create_file?(type,path,content)
+        # raises exception if these files already exists and content differs
+        if File.exists?(path)
+          existing = File.open(path).read
+          if existing == content
+            true
+          else
+            raise "RSA #{type} key already exists and differs from one in payload"
+          end
+        end
+      end
+    end
+  end
+end
+
+    

data/mcollective_additions/plugins/v1.2/agent/netstat.ddl

@@ -0,0 +1,9 @@
+metadata    :name        => "netstat info",
+            :description => "Agent to get netstat info",
+            :author      => "Reactor8",
+            :license     => "",
+            :version     => "",
+            :url         => "",
+            :timeout     => 2
+action "get_tcp_udp", :description => "get tcp and udp info" do
+end

data/mcollective_additions/plugins/v1.2/agent/netstat.rb

@@ -0,0 +1,34 @@
+module MCollective
+  module Agent
+    class Netstat < RPC::Agent
+      metadata    :name        => "netstat info",
+                  :description => "Agent to get netstat info",
+                  :author      => "Reactor8",
+                  :license     => "",
+                  :version     => "",
+                  :url         => "",
+                  :timeout     => 2
+      action "get_tcp_udp" do 
+        output = `netstat -nltpu`
+        results = output.scan(/(^[a-z0-9]+)\s+(\d)\s+(\d)\s+([0-9:.*]+)\s+([0-9:.*]+)\s+(LISTEN)?\s+([0-9a-zA-Z\/\-: ]+)/m)
+
+        netstat_result = []
+        results.each do |result|
+          netstat_packet = {}
+          netstat_packet.store(:protocol, result[0])
+          netstat_packet.store(:recv_q,   result[1])
+          netstat_packet.store(:send_q,   result[2])
+          netstat_packet.store(:local,    result[3])
+          netstat_packet.store(:foreign,  result[4])
+          netstat_packet.store(:state,    result[5])
+          netstat_packet.store(:program,  result[6].strip)
+          netstat_result << netstat_packet
+        end
+
+        reply[:data]  = netstat_result
+        reply[:pbuilderid] = Facts["pbuilderid"]
+        reply[:status] = :ok
+      end
+    end
+  end
+end

data/mcollective_additions/plugins/v1.2/agent/puppet_apply.ddl

@@ -0,0 +1,9 @@
+metadata    :name        => "run puppet actions",
+            :description => "Agent to initiate Puppet apply runs",
+            :author      => "Reactor8",
+            :license     => "",
+            :version     => "",
+            :url         => "",
+            :timeout     => 600
+action "run", :description => "puppet apply" do
+end

data/mcollective_additions/plugins/v1.2/agent/puppet_apply.rb

@@ -0,0 +1,630 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'puppet'
+require 'grit'
+require 'tempfile'
+require 'fileutils'
+
+#dont want to run standard hooks and just want store configs for catalogs/resources, not for facts ..
+Puppet.settings.set_value(:storeconfigs,true,:memory, :dont_trigger_handles => true)
+Puppet::Resource::Catalog.indirection.cache_class = :store_configs
+Puppet::Resource.indirection.terminus_class = :store_configs
+
+#TODO: move to be shared by agents
+PuppetApplyLogDir = "/var/log/puppet"
+ModulePath =  "/etc/puppet/modules"
+
+module MCollective
+  module Agent
+    class Puppet_apply < RPC::Agent
+      metadata    :name        => "run puppet actions",
+                  :description => "Agent to initiate Puppet apply runs",
+                  :author      => "Reactor8",
+                  :license     => "",
+                  :version     => "",
+                  :url         => "",
+                  :timeout     => 600
+      def initialize()
+        super()
+        @log = Log.instance
+        @reply_data = nil
+      end
+
+      def run_action
+        #validate :components_with_attributes
+        #validate :version_context
+	#validate :node_manifest
+
+        validate :task_id, Fixnum
+        validate :top_task_id, Fixnum
+        log_params()
+        @reply_data = nil
+        @msg_id = request.uniqid
+        @task_info = [:task_id,:top_task_id].inject({}) do |h,k|
+          h.merge(k => request[k])
+        end.merge(:msg_id => @msg_id)
+
+        more_generic_response = Response.new()
+        puppet_run_response = nil
+        begin
+          response = pull_recipes(request[:version_context])
+          return set_reply!(response) if response.failed?()
+          puppet_run_response = run(request)
+        rescue Exception => e
+          more_generic_response.set_status_failed!()
+          error_info = {
+            :error => {
+              :message => e.inspect
+            }
+          }
+          more_generic_response.merge!(error_info)
+        end
+        set_reply?(puppet_run_response || more_generic_response)
+      end
+     private
+      #TODO: this should be common accross Agents after pulling out aagent specfic params
+      def pull_recipes(version_context)
+        ret = Response.new
+        begin
+          version_context.each do |vc|
+            repo = vc[:repo]
+            implementation = vc[:implementation]
+            branch_name = vc[:branch]
+            repo_dir = "#{ModulePath}/#{implementation}"
+            unless File.exists?(repo_dir)
+              begin
+                raise "git server is not set in facts" unless git_server = Facts["git-server"]
+                remote_git = "#{git_server}:#{repo}"
+                ClientRepo.clone(remote_git,repo_dir)
+               rescue Exception => e
+                #to achive idempotent behavior fully remove directory that has not been fully cloned
+                FileUtils.rm_rf repo_dir
+                raise e
+              end
+            end
+            Dir.chdir(repo_dir) do
+              begin 
+                repo = ClientRepo.new(".")
+                if repo.branch_exists?(branch_name)
+                  current_branch = repo.current_branch
+                  repo.git_command__checkout(branch_name) unless current_branch == branch_name
+                  repo.git_command__pull(branch_name)
+                else
+                  unless repo.remote_branch_exists?("origin/#{branch_name}")
+                    repo.git_command__pull()
+                  end
+                  repo.git_command__checkout_track_branch(branch_name)
+                end
+              end
+            end
+          end
+          ret.set_status_succeeded!()
+         rescue Exception => e
+          ret.set_status_failed!()
+          error_info = {
+            :error => {
+              :message => e.inspect
+            }
+          }
+          ret.merge!(error_info)
+         ensure
+          #TODO: may mot be needed now switch to grit
+          #git library sets these vars; so resting here
+          %w{GIT_DIR GIT_INDEX_FILE GIT_WORK_TREE}.each{|var|ENV[var]=nil}
+        end
+        ret 
+      end
+
+      def run(request)
+       	cmps_with_attrs = request[:components_with_attributes]
+       	node_manifest = request[:node_manifest]
+        inter_node_stage = request[:inter_node_stage]
+
+        clean_state()
+        ret = nil
+        log_file_path = log_file_path()
+        log_file = nil
+        begin
+          save_stderr = nil
+          log_file = File.open(log_file_path,"a")
+          log_file.close
+          Puppet[:autoflush] = true
+          most_recent_link = most_recent_file_path()
+          File.delete(most_recent_link) if File.exists? most_recent_link
+          File.symlink(log_file_path,most_recent_link)
+
+          execute_lines = node_manifest || ret_execute_lines(cmps_with_attrs)
+          execute_string = execute_lines.join("\n")
+          @log.info("\n----------------execute_string------------\n#{execute_string}\n----------------execute_string------------")
+          File.open("/tmp/site_stage#{inter_node_stage}.pp","w"){|f| f << execute_string}
+cmd_line = 
+  [
+   "apply", 
+   "-l", log_file_path, 
+   "-d", 
+   "--report", true, "--reports", "r8report",
+   "--storeconfigs_backend", "r8_storeconfig_backend",
+   "-e", execute_string
+  ]
+cmd = "/usr/bin/puppet" 
+          save_stderr = $stderr
+          stderr_capture = Tempfile.new("stderr")
+          $stderr = stderr_capture
+          Puppet::Util::CommandLine.new(cmd,cmd_line).execute
+         rescue SystemExit => exit
+          report_status = Report::get_status()
+          report_info = Report::get_report_info()
+          exit_status = exit.status
+          @log.info("exit.status = #{exit_status}")
+          @log.info("report_status = #{report_status}")
+          @log.info("report_info = #{report_info.inspect}")
+          return_code = ((report_status == :failed || report_info[:errors]) ? 1 : exit_status)
+          ret ||= Response.new()
+          if return_code == 0
+            if dynamic_attributes = process_dynamic_attributes?(cmps_with_attrs)
+              @log.info("dynamic_attributes = #{dynamic_attributes.inspect}")
+              ret.set_dynamic_attributes!(dynamic_attributes)
+            end
+            ret.set_status_succeeded!()
+          else
+            ret.set_status_failed!()
+            error_info = {
+              :return_code => return_code            
+            }
+            error_info.merge!(:errors => report_info[:errors]) if (report_info||{})[:errors]
+            ret.merge!(error_info)
+          end
+         rescue Exception => e
+          pp [e,e.backtrace[0..5]]
+          log_error = ([e.inspect]+[e.backtrace[0..5]]).join("\n")
+          @log.info("\n----------------error-----\n#{log_error}\n----------------error-----")
+          ret ||= Response.new()
+          ret.set_status_failed!()
+          error_info = {
+            :error => {
+              :message => e.inspect
+            }
+          }
+          ret.merge!(error_info)
+         ensure
+          if save_stderr #test if this is nil as to whether did the stderr swap
+            $stderr = save_stderr
+            stderr_capture.rewind
+            stderr_msg = stderr_capture.read
+            stderr_capture.close
+            stderr_capture.unlink
+            if stderr_msg and not stderr_msg.empty?
+              ret[:errors] = (ret[:errors]||[]) + [{:message => stderr_msg}]
+              Puppet::err stderr_msg 
+              Puppet::info "(end)"
+            end
+          end
+          Puppet::Util::Log.close_all()
+        end
+        ret 
+      end
+
+      #TODO: cleanup fn; need to fix on serevr side; inconsient use of symbol and string keys 
+      #execute_lines
+      def ret_execute_lines(cmps_with_attrs)
+        ret = Array.new
+        @import_statement_modules = Array.new
+        cmps_with_attrs.each_with_index do |cmp_with_attrs,i|
+          stage = i+1
+          module_name = cmp_with_attrs["module_name"]
+          ret << "stage{#{quote_form(stage)} :}"
+          attrs = process_and_return_attr_name_val_pairs(cmp_with_attrs)
+          stage_assign = "stage => #{quote_form(stage)}"
+          case cmp_with_attrs["component_type"]
+           when "class"
+            cmp = cmp_with_attrs["name"]
+            raise "No component name" unless cmp
+            if imp_stmt = needs_import_statement?(cmp,module_name)
+              ret << imp_stmt 
+            end
+
+            #TODO: see if need \" and quote form
+            attr_str_array = attrs.map{|k,v|"#{k} => #{process_val(v)}"} + [stage_assign]
+            attr_str = attr_str_array.join(", ")
+            ret << "class {\"#{cmp}\": #{attr_str}}"
+           when "definition"
+            defn = cmp_with_attrs["name"]
+            raise "No definition name" unless defn
+            name_attr = nil
+            attr_str_array = attrs.map do |k,v|
+              if k == "name"
+                name_attr = quote_form(v)
+                nil
+              else
+                "#{k} => #{process_val(v)}"
+              end
+            end.compact
+            attr_str = attr_str_array.join(", ")
+            raise "No name attribute for definition" unless name_attr
+            if imp_stmt = needs_import_statement?(defn,module_name)
+              ret << imp_stmt
+            end
+            #putting def in class because defs cannot go in stages
+            class_wrapper = "stage#{stage.to_s}"
+            ret << "class #{class_wrapper} {"
+            ret << "#{defn} {#{name_attr}: #{attr_str}}"
+            ret << "}"
+            ret << "class {\"#{class_wrapper}\": #{stage_assign}}"
+          end
+        end
+        size = cmps_with_attrs.size
+        if size > 1
+          ordering_statement = (1..cmps_with_attrs.size).map{|s|"Stage[#{s.to_s}]"}.join(" -> ")
+          ret << ordering_statement
+        end
+
+        if attr_val_stmts = get_attr_val_statements(cmps_with_attrs)
+          ret += attr_val_stmts
+        end
+        ret
+      end
+
+      #removes imported collections and puts them on global array
+      def process_and_return_attr_name_val_pairs(cmp_with_attrs)
+        ret = Hash.new
+        return ret unless attrs = cmp_with_attrs["attributes"]
+        cmp_name = cmp_with_attrs["name"]
+        attrs.each do |attr_info|
+          attr_name = attr_info["name"]
+          val = attr_info["value"]
+          case attr_info["type"] 
+           when "attribute"
+            ret[attr_name] = val
+          when "imported_collection"
+            add_imported_collection(cmp_name,attr_name,val,{"resource_type" => attr_info["resource_type"], "import_coll_query" =>  attr_info["import_coll_query"]})
+          else raise "unexpected attribute type (#{attr_info["type"]})"
+          end
+        end
+        ret
+      end
+
+      def get_attr_val_statements(cmps_with_attrs)
+        ret = Array.new
+        cmps_with_attrs.each do |cmp_with_attrs|
+          (cmp_with_attrs["dynamic_attributes"]||[]).each do |dyn_attr|
+            if dyn_attr[:type] == "default_variable"
+              qualified_var = "#{cmp_with_attrs["name"]}::#{dyn_attr[:name]}"
+              ret << "r8::export_variable{'#{qualified_var}' :}"
+            end
+          end
+        end
+        ret.empty? ? nil : ret
+      end
+
+      
+      def needs_import_statement?(cmp_or_def,module_name)
+        return nil if cmp_or_def =~ /::/
+        return nil if @import_statement_modules.include?(module_name)
+        @import_statement_modules << module_name
+        "import '#{module_name}'"
+      end
+
+      def process_val(val)
+        #a guarded val
+        if val.kind_of?(Hash) and val.size == 1 and val.keys.first == "__ref"
+          "$#{val.values.join("::")}"
+        else
+          quote_form(val)
+        end
+      end
+
+      def process_dynamic_attributes?(cmps_with_attrs)
+        ret = Array.new
+        cmps_with_attrs.each do |cmp_with_attrs|
+          cmp_name = cmp_with_attrs["name"]
+          dyn_attrs = cmp_with_attrs["dynamic_attributes"]
+          if dyn_attrs and not dyn_attrs.empty?
+            resource_ref = resource_ref(cmp_with_attrs)
+            dyn_attrs.each do |dyn_attr|
+              if el = dynamic_attr_response_el(cmp_name,dyn_attr)
+                ret << el
+              end
+            end
+          end
+        end
+        ret.empty? ? nil : ret
+      end
+      def dynamic_attr_response_el(cmp_name,dyn_attr)
+        ret = nil
+        val = 
+          if dyn_attr[:type] == "exported_resource" 
+            dynamic_attr_response_el__exported_resource(cmp_name,dyn_attr)
+          elsif dyn_attr[:type] == "default_variable"
+            dynamic_attr_response_el__default_attribute(cmp_name,dyn_attr)
+          else #assumption only three types: "exported_resource", "default_attribute, (and other can by "dynamic")
+            dynamic_attr_response_el__default_attribute(cmp_name,dyn_attr)||dynamic_attr_response_el__dynamic(cmp_name,dyn_attr)
+          end
+        if val
+          ret = {
+            :component_name => cmp_name,
+            :attribute_name => dyn_attr[:name],
+            :attribute_id => dyn_attr[:id],
+            :attribute_val => val
+          }
+        end
+        ret
+      end
+
+      def dynamic_attr_response_el__exported_resource(cmp_name,dyn_attr)
+        ret = nil 
+        if cmp_exp_rscs = exported_resources(cmp_name)
+          cmp_exp_rscs.each do |title,val|
+            return val if exp_rsc_match(title,dyn_attr[:title_with_vars])
+          end
+        else
+          @log.info("no exported resources set for component #{cmp_name}")
+        end
+        ret
+      end
+
+      #TODO: more sophistiacted would take var bindings
+      def exp_rsc_match(title,title_with_vars)
+        regexp_str = regexp_string(title_with_vars)
+        @log.info("debug: regexp_str = #{regexp_str}")
+        title =~ Regexp.new("^#{regexp_str}$") if regexp_str
+      end
+
+      def regexp_string(title_with_vars)
+        if title_with_vars.kind_of?(Array)
+          case title_with_vars.first 
+          when "variable" then ".+"
+          when "fn" then regexp_string__when_op(title_with_vars)
+          else
+            @log.info("unexpected first element in title with vars (#{title_with_vars.first})")
+            nil
+          end
+        else
+          title_with_vars.gsub(".","\\.")
+        end
+      end
+
+      def regexp_string__when_op(title_with_vars)
+        unless title_with_vars[1] == "concat"
+          @log.info("not treating operation (#{title_with_vars[1]})")
+          return nil
+        end
+        title_with_vars[2..title_with_vars.size-1].map do |x|
+          return nil unless re = regexp_string(x)
+          re
+        end.join("")
+      end
+
+      def dynamic_attr_response_el__dynamic(cmp_name,dyn_attr)
+        ret = nil
+        attr_name = dyn_attr[:name]
+        filepath = (exported_files(cmp_name)||{})[attr_name]
+        #TODO; legacy; remove when deprecate 
+        filepath ||= "/tmp/#{cmp_name.gsub(/::/,".")}.#{attr_name}"
+        begin
+          val = File.open(filepath){|f|f.read}.chomp
+          ret = val unless val.empty?
+         rescue Exception
+        end
+        ret
+      end
+
+      def dynamic_attr_response_el__default_attribute(cmp_name,dyn_attr)
+        ret = nil
+        unless cmp_exp_vars = exported_variables(cmp_name)
+          @log.info("no exported varaibles for component #{cmp_name}")
+          return ret
+        end
+        
+        attr_name = dyn_attr[:name]
+        unless cmp_exp_vars.has_key?(attr_name)
+          @log.info("no exported variable entry for component #{cmp_name}, attribute #{dyn_attr[:name]})")
+          return ret
+        end
+
+        cmp_exp_vars[attr_name]
+      end
+
+      def clean_state()
+        [:exported_resources, :exported_variables, :report_status, :imported_collections].each do |k|
+          Thread.current[k] = nil if Thread.current.keys.include?(k)
+        end
+      end
+      def exported_resources(cmp_name)
+        (Thread.current[:exported_resources]||{})[cmp_name]
+      end
+      def exported_variables(cmp_name)
+        (Thread.current[:exported_variables]||{})[cmp_name]
+      end
+      def exported_files(cmp_name)
+        (Thread.current[:exported_files]||{})[cmp_name]
+      end
+      def add_imported_collection(cmp_name,attr_name,val,context={})
+        p = (Thread.current[:imported_collections] ||= Hash.new)[cmp_name] ||= Hash.new
+        p[attr_name] = {"value" => val}.merge(context)
+      end
+
+      def resource_ref(cmp_with_attrs)
+        case cmp_with_attrs["component_type"]
+        when "class"
+          "Class[#{quote_form(cmp_with_attrs["name"])}]"
+        when "definition"
+          defn = cmp_with_attrs["name"]
+          def_name = (cmp_with_attrs["attributes"].find{|k,v|k == "name"}||[]).last
+          raise "Cannot find the name associated with definition #{defn}" unless def_name
+          "#{capitalize_resource_name(defn)}[#{quote_form(def_name)}]"
+        else
+          raise "Reference to type #{cmp_with_attrs["component_type"]} not treated"
+        end
+      end
+
+      def self.capitalize_resource_name(name)
+        name.split('::').map{|p|p.capitalize}.join("::")
+      end
+      def capitalize_resource_name(name)
+        self.class.capitalize_resource_name(name)
+      end
+
+      DynamicVarDefName = "r8_dynamic_vars::set_var"
+      DynamicVarDefNameRN = capitalize_resource_name(DynamicVarDefName)
+
+      def quote_form(obj)
+        if obj.kind_of?(Hash) 
+          "{#{obj.map{|k,v|"#{quote_form(k)} => #{quote_form(v)}"}.join(",")}}"
+        elsif obj.kind_of?(Array)
+          "[#{obj.map{|el|quote_form(el)}.join(",")}]"
+        elsif obj.kind_of?(String)
+          "\"#{obj}\""
+        elsif obj.nil?
+          "nil"
+        else
+          obj.to_s
+        end
+      end
+
+      def set_reply!(response)
+        reply.data = @reply_data = response.to_hash
+      end
+      def set_reply?(response)
+        reply.data = @reply_data ||= response.to_hash
+      end
+      def log_params()
+        @log.info("params: #{request.data.inspect}")
+      end
+      
+      def log_file_path()
+        "#{PuppetApplyLogDir}/#{id_info()}.log"
+      end
+      def most_recent_file_path()
+        "#{PuppetApplyLogDir}/last.log"
+      end
+      def id_info()
+        [:msg_id,:task_id,:top_task_id].map do |k|
+          if @task_info.has_key?(k)
+            "#{k}:#{@task_info[k].to_s}"
+          end
+        end.compact.join(":")
+      end
+
+      #TODO: this should be common accross Agents
+      class ClientRepo
+        def self.clone(remote_git,repo_dir)
+          Grit::Git.new("").clone(git_command_opts(),remote_git,repo_dir)
+        end
+        def initialize(path)
+          @path = path
+          @grit_repo = Grit::Repo.new(path)
+          @index = @grit_repo.index #creates new object so use @index, not grit_repo
+        end
+        
+        def branch_exists?(branch_name)
+          @grit_repo.heads.find{|h|h.name == branch_name} ? true : nil
+        end
+        
+        def remote_branch_exists?(branch_name)
+          @grit_repo.remotes.find{|h|h.name == branch_name} ? true : nil
+        end
+        
+        def git_command__checkout_track_branch(branch_name)
+          git_command().checkout(git_command_opts(),"--track","-b", branch_name, "origin/#{branch_name}")
+        end
+
+        def current_branch()
+          @grit_repo.head.name
+        end
+  
+        def git_command__checkout(branch_name) 
+          git_command().checkout(git_command_opts(),branch_name)
+        end
+        
+        def git_command__pull(branch_name=nil)
+          branch_name ? git_command().pull(git_command_opts(),"origin",branch_name) : git_command().pull(git_command_opts(),"origin")
+        end
+       private
+        def self.git_command_opts()
+          {:raise => true, :timeout => 60}
+        end
+        def git_command_opts()
+          self.class.git_command_opts()
+        end
+        def git_command()
+          @grit_repo.git
+        end
+      end
+
+      #TODO: this should be common accross Agents
+      class Response < Hash
+        def initialize(hash={})
+          super()
+          self.merge!(hash)
+          self[:status] = :unknown unless hash.has_key?(:status)
+        end
+        
+        def to_hash()
+          Hash.new.merge(self)
+        end
+
+        def failed?()
+          self[:status] == :failed
+        end
+
+        def set_status_failed!()
+          self[:status] = :failed
+        end
+        def set_status_succeeded!()
+          self[:status] = :succeeded
+        end
+        def set_dynamic_attributes!(dynamic_attributes)
+          self[:dynamic_attributes] = dynamic_attributes
+        end
+      end
+      class ResponseFailed < Response
+        def initialize(error,info={})
+          super({:status => :failed, :error => error}.merge(info))
+        end
+      end
+      class ResponseSucceeded < Response
+        def initialize(info={})
+          super({:status => :succeeded}.merge(info))
+        end
+      end
+    end
+  end
+  class Report
+    def self.set_status(status)
+      Thread.current[:report_status] = status.to_sym
+    end
+    def self.get_status()
+      Thread.current[:report_status]
+    end
+    def self.set_report_info(report_info)
+      Thread.current[:report_info] = report_info
+    end
+    def self.get_report_info()
+      Thread.current[:report_info]
+    end
+  end
+end
+
+Puppet::Reports.register_report(:r8report) do
+  desc "report for R8 agent"
+
+  def process
+    MCollective::Report.set_status(status)
+
+    #TODO: right now just passing raw info nack on errors; may normalize here
+    report_info = Hash.new
+    errors = logs.select{|log_el|log_el.level == :err}
+    unless errors.empty?
+      report_info[:errors] = errors.map do |err|
+        {
+          "message" => err.message,
+          "source" => err.source,
+          "tags" => err.tags,
+          "time" => err.time
+        }
+      end
+    end
+    MCollective::Report.set_report_info(report_info)
+    self
+  end
+end