puppet_agent_mgr 0.0.2

data/lib/puppet_agent_mgr.rb

@@ -0,0 +1,25 @@
+require 'puppet_agent_mgr/common'
+
+module PuppetAgentMgr
+  def self.manager
+    require 'puppet'
+    require 'json'
+
+    if Puppet.version =~ /^(\d+)/
+      case $1
+        when "2"
+          require 'puppet_agent_mgr/v2/manager'
+          return PuppetAgentMgr::V2::Manager.new
+
+        when "3"
+          require 'puppet_agent_mgr/v3/manager'
+          return PuppetAgentMgr::V3::Manager.new
+
+        else
+          raise "Cannot manage Puppet version %s" % $1
+      end
+    else
+      raise "Cannot determine the Puppet major version"
+    end
+  end
+end

data/lib/puppet_agent_mgr/common.rb

@@ -0,0 +1,195 @@
+module PuppetAgentMgr
+  module Common
+    extend Common
+
+    # is a catalog being applied rigt now?
+    def stopped?
+      !applying?
+    end
+
+    # is the daemon running but not applying a catalog
+    def idling?
+      (daemon_present? && !applying?)
+    end
+
+    # is the agent enabled
+    def enabled?
+      !disabled?
+    end
+
+    # seconds since the last catalog was applied
+    def since_lastrun
+      (Time.now - lastrun).to_i
+    end
+
+    # if a resource is being managed, resource in the syntax File[/x] etc
+    def managing_resource?(resource)
+      managed_resources.include?(resource.downcase)
+    end
+
+    # how many resources are managed
+    def managed_resources_count
+      managed_resources.size
+    end
+
+    def run_in_foreground(clioptions)
+      command =["puppet", "agent", "--test", "--color=false"]
+      command.concat(clioptions)
+
+      %x[#{command.join(' ')}]
+    end
+
+    def run_in_background(clioptions)
+      command =["puppet", "agent", "--onetime", "--daemonize", "--color=false"]
+      command.concat(clioptions)
+
+      %x[#{command.join(' ')}]
+    end
+
+    def validate_name(name)
+      if name.length == 1
+        return false unless name =~ /\A[a-zA-Z]\Z/
+      else
+        return false unless name =~ /\A[a-zA-Z0-9_]+\Z/
+      end
+
+      true
+    end
+
+    def create_common_puppet_cli(noop, tags, environment, server)
+      opts = []
+
+      (host, port) = server.to_s.split(":")
+
+      raise("Invalid hostname '%s' specified" % host) if host && !(host =~ /\A(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])\Z/)
+      raise("Invalid master port '%s' specified" % port) if port && !(port =~ /\A\d+\Z/)
+      raise("Invalid environment '%s' specified" % environment) if environment && !validate_name(environment)
+
+      unless tags.empty?
+        [tags].flatten.each do |tag|
+          tag.split("::").each do |part|
+            raise("Invalid tag '%s' specified" % tag) unless validate_name(part)
+          end
+        end
+
+        opts << "--tags %s" % tags.join(",") if !tags.empty?
+      end
+
+      opts << "--noop" if noop
+      opts << "--environment %s" % environment if environment
+      opts << "--server %s" % host if host
+      opts << "--masterport %s" % port if port
+
+      opts
+    end
+
+    # do a run based on the following options:
+    #
+    # :foreground_run - runs in the foreground a --test run
+    # :signal_daemon  - if the daemon is running, sends it USR1 to wake it up
+    # :noop           - does a noop run if possible
+    # :tags           - an array of tags to limit the run to
+    # :environment    - the environment to run
+    # :server         - the puppet master to use, can be some.host or some.host:port
+    #
+    # else a single background run will be attempted but this will fail if a idling
+    # daemon is present and :signal_daemon was false
+    def runonce!(options={})
+      valid_options = [:noop, :signal_daemon, :foreground_run, :tags, :environment, :server]
+
+      options.keys.each do |opt|
+        raise("Unknown option %s specified" % opt) unless valid_options.include?(opt)
+      end
+
+      raise "Puppet is currently applying a catalog, cannot run now" if applying?
+      raise "Puppet is disabled, cannot run now" if disabled?
+
+      noop = options.fetch(:noop, false)
+      signal_daemon = options.fetch(:signal_daemon, true)
+      foreground_run = options.fetch(:foreground_run, false)
+      environment = options[:environment]
+      tags = [ options[:tags] ].flatten.compact
+      server = options[:server]
+
+      clioptions = create_common_puppet_cli(noop, tags, environment, server)
+
+      if idling? && signal_daemon && !clioptions.empty?
+        raise "Cannot specify any custom puppet options when the daemon is running"
+      end
+
+      if foreground_run
+        run_in_foreground(clioptions)
+      elsif idling? && signal_daemon
+        signal_running_daemon
+      else
+        raise "Cannot run in the background if the daemon is present" if daemon_present?
+        run_in_background(clioptions)
+      end
+    end
+
+    # simple utility to return a hash with lots of useful information about the state of the agent
+    def status
+      status = {:applying => applying?,
+                :enabled => enabled?,
+                :daemon_present => daemon_present?,
+                :lastrun => lastrun,
+                :disable_message => lock_message,
+                :since_lastrun => (Time.now.to_i - lastrun)}
+
+      if !status[:enabled]
+        status[:status] = "disabled"
+
+      elsif status[:applying]
+        status[:status] = "applying a catalog"
+
+      elsif status[:daemon_present] && status[:applying]
+        status[:status] = "idling"
+
+      elsif !status[:applying]
+        status[:status] = "stopped"
+
+      end
+
+      status[:message] = "Currently %s; last completed run %s ago" % [status[:status], seconds_to_human(status[:since_lastrun])]
+
+      status
+    end
+
+    def atomic_file(file)
+      tempfile = Tempfile.new(File.basename(file), File.dirname(file))
+
+      yield(tempfile)
+
+      tempfile.close
+      File.rename(tempfile.path, file)
+    end
+
+    def seconds_to_human(seconds)
+      days = seconds / 86400
+      seconds -= 86400 * days
+
+      hours = seconds / 3600
+      seconds -= 3600 * hours
+
+      minutes = seconds / 60
+      seconds -= 60 * minutes
+
+      if days > 1
+        return "%d days %d hours %d minutes %02d seconds" % [days, hours, minutes, seconds]
+
+      elsif days == 1
+        return "%d day %d hours %d minutes %02d seconds" % [days, hours, minutes, seconds]
+
+      elsif hours > 0
+        return "%d hours %d minutes %02d seconds" % [hours, minutes, seconds]
+
+      elsif minutes > 0
+        return "%d minutes %02d seconds" % [minutes, seconds]
+
+      else
+        return "%02d seconds" % seconds
+
+      end
+    end
+  end
+end

data/lib/puppet_agent_mgr/v2/manager.rb

@@ -0,0 +1,71 @@
+module PuppetAgentMgr::V2
+  class Manager
+    include PuppetAgentMgr::Common
+
+    if Puppet.features.microsoft_windows?
+      require 'puppet_agent_mgr/v2/windows'
+      include Windows
+    else
+      require 'puppet_agent_mgr/v2/unix'
+      include Unix
+    end
+
+    # enables the puppet agent, it can now start applying catalogs again
+    def enable!
+      raise "Already enabled" if enabled?
+      File.unlink(Puppet[:puppetdlockfile])
+    end
+
+    # disable the puppet agent, on version 2.x the message is ignored
+    def disable!(msg=nil)
+      raise "Already disabled" unless enabled?
+      File.open(Puppet[:puppetdlockfile], "w") { }
+
+      ""
+    end
+
+    # all the managed resources
+    def managed_resources
+      # need to add some caching here based on mtime of the resources file
+      return [] unless File.exist?(Puppet[:resourcefile])
+
+      File.readlines(Puppet[:resourcefile]).map do |resource|
+        resource.chomp
+      end
+    end
+
+    # epoch time when the last catalog was applied
+    def lastrun
+      summary = load_summary
+
+      Integer(summary["time"].fetch("last_run", 0))
+    end
+
+    # the current lock message, always "" on 2.0
+    def lock_message
+      ""
+    end
+
+    # is the agent disabled
+    def disabled?
+      if File.exist?(Puppet[:puppetdlockfile])
+        if File::Stat.new(Puppet[:puppetdlockfile]).zero?
+          return true
+        end
+      end
+
+      false
+    end
+
+    # loads the summary file and makes sure that some keys are always present
+    def load_summary
+      summary = {"changes" => {}, "time" => {}, "resources" => {}, "version" => {}, "events" => {}}
+
+      summary.merge!(YAML.load_file(Puppet[:lastrunfile])) if File.exist?(Puppet[:lastrunfile])
+
+      summary["resources"] = {"failed"=>0, "changed"=>0, "total"=>0, "restarted"=>0, "out_of_sync"=>0}.merge!(summary["resources"])
+
+      summary
+    end
+  end
+end

data/lib/puppet_agent_mgr/v2/unix.rb

@@ -0,0 +1,44 @@
+module PuppetAgentMgr::V2
+  module Unix
+    extend Unix
+    # is the agent daemon currently in the unix process list?
+    def daemon_present?
+      if File.exist?(Puppet[:pidfile])
+        return has_process_for_pid?(File.read(Puppet[:pidfile]))
+      end
+
+      return false
+    end
+
+    # is the agent currently applying a catalog
+    def applying?
+      return false if disabled?
+
+      if File::Stat.new(Puppet[:puppetdlockfile]).size > 0
+        return has_process_for_pid(File.read(Puppet[:puppetdlockfile]))
+      end
+
+      return false
+    rescue
+      return false
+    end
+
+    def signal_running_daemon
+      pid = File.read(Puppet[:pidfile])
+
+      if has_process_for_pid?(pid)
+        begin
+          Process.kill("USR1", Integer(pid))
+        rescue Exception => e
+          raise "Failed to signal the puppet agent at pid %s: %s" % [pid, e.to_s]
+        end
+      else
+        run_in_background
+      end
+    end
+
+    def has_process_for_pid?(pid)
+      !!Process.kill(0, Integer(pid)) rescue false
+    end
+  end
+end

data/lib/puppet_agent_mgr/v2/windows.rb

@@ -0,0 +1 @@
+raise "Window is not supported yet"

data/lib/puppet_agent_mgr/v3/manager.rb

@@ -0,0 +1,75 @@
+module PuppetAgentMgr::V3
+  class Manager
+    if Puppet.features.microsoft_windows?
+      require 'puppet_agent_mgr/v3/windows'
+      include Windows
+    else
+      require 'puppet_agent_mgr/v3/unix'
+      include Unix
+    end
+
+    include PuppetAgentMgr::Common
+
+    # enables the puppet agent, it can now start applying catalogs again
+    def enable!
+      raise "Already enabled" if enabled?
+      File.unlink(Puppet[:agent_disabled_lockfile])
+    end
+
+    # disable the puppet agent, on version 2.x the message is ignored
+    def disable!(msg=nil)
+      raise "Already disabled" unless enabled?
+
+      msg = "Disabled using the Ruby API at %s" % Time.now.strftime("%c") unless msg
+
+      atomic_file(Puppet[:agent_disabled_lockfile]) do |f|
+        f.print(JSON.dump(:disabled_message => msg))
+      end
+
+      msg
+    end
+
+    # all the managed resources
+    def managed_resources
+      # need to add some caching here based on mtime of the resources file
+      return [] unless File.exist?(Puppet[:resourcefile])
+
+      File.readlines(Puppet[:resourcefile]).map do |resource|
+        resource.chomp
+      end
+    end
+
+    # epoch time when the last catalog was applied
+    def lastrun
+      summary = load_summary
+
+      Integer(summary["time"].fetch("last_run", 0))
+    end
+
+    # the current lock message, always "" on 2.0
+    def lock_message
+      if disabled?
+        lock_data = JSON.parse(File.read(Puppet[:agent_disabled_lockfile]))
+        return lock_data["disabled_message"]
+      else
+        return ""
+      end
+    end
+
+    # is the agent disabled
+    def disabled?
+      File.exist?(Puppet[:agent_disabled_lockfile])
+    end
+
+    # loads the summary file and makes sure that some keys are always present
+    def load_summary
+      summary = {"changes" => {}, "time" => {}, "resources" => {}, "version" => {}, "events" => {}}
+
+      summary.merge!(YAML.load_file(Puppet[:lastrunfile])) if File.exist?(Puppet[:lastrunfile])
+
+      summary["resources"] = {"failed"=>0, "changed"=>0, "total"=>0, "restarted"=>0, "out_of_sync"=>0}.merge!(summary["resources"])
+
+      summary
+    end
+  end
+end

data/lib/puppet_agent_mgr/v3/unix.rb

@@ -0,0 +1,44 @@
+module PuppetAgentMgr::V3
+  module Unix
+    extend Unix
+    # is the agent daemon currently in the unix process list?
+    def daemon_present?
+      if File.exist?(Puppet[:agentpidfile])
+        return has_process_for_pid?(File.read(Puppet[:agentpidfile]))
+      end
+
+      return false
+    end
+
+    # is the agent currently applying a catalog
+    def applying?
+      return false if disabled?
+
+      if File::Stat.new(Puppet[:pidfile]).size > 0
+        return has_process_for_pid(File.read(Puppet[:pidfile]))
+      end
+
+      return false
+    rescue
+      return false
+    end
+
+    def signal_running_daemon
+      pid = File.read(Puppet[:agentpidfile])
+
+      if has_process_for_pid?(pid)
+        begin
+          Process.kill("USR1", Integer(pid))
+        rescue Exception => e
+          raise "Failed to signal the puppet agent at pid %s: %s" % [pid, e.to_s]
+        end
+      else
+        run_in_background
+      end
+    end
+
+    def has_process_for_pid?(pid)
+      !!Process.kill(0, Integer(pid)) rescue false
+    end
+  end
+end

data/lib/puppet_agent_mgr/v3/windows.rb

@@ -0,0 +1 @@
+raise "Window is not supported yet"

data/lib/puppet_agent_mgr/version.rb

@@ -0,0 +1,3 @@
+module PuppetAgentMgr
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: puppet_agent_mgr
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-27 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: A simple library that wraps the logic around the locks, pids, JSON filesu and YAML files that makes up the Puppet Agent status.  Suppots Puppet 2.7.x and 3.0.x.
+email: rip@devco.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/puppet_agent_mgr/common.rb
+- lib/puppet_agent_mgr/v3/windows.rb
+- lib/puppet_agent_mgr/v3/manager.rb
+- lib/puppet_agent_mgr/v3/unix.rb
+- lib/puppet_agent_mgr/version.rb
+- lib/puppet_agent_mgr/v2/windows.rb
+- lib/puppet_agent_mgr/v2/manager.rb
+- lib/puppet_agent_mgr/v2/unix.rb
+- lib/puppet_agent_mgr.rb
+has_rdoc: true
+homepage: http://devco.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Puppet Agent Manager
+test_files: []
+