mcollective-client 1.3.3

data/lib/mcollective/unix_daemon.rb

@@ -0,0 +1,37 @@
+module MCollective
+  class UnixDaemon
+    # Daemonize the current process
+    def self.daemonize
+      fork do
+        Process.setsid
+        exit if fork
+        Dir.chdir('/tmp')
+        STDIN.reopen('/dev/null')
+        STDOUT.reopen('/dev/null', 'a')
+        STDERR.reopen('/dev/null', 'a')
+
+        yield
+      end
+    end
+
+    def self.daemonize_runner(pid=nil)
+      raise "The Unix Daemonizer can not be used on the Windows Platform" if Util.windows?
+
+      UnixDaemon.daemonize do
+        if pid
+          begin
+            File.open(pid, 'w') {|f| f.write(Process.pid) }
+          rescue Exception => e
+          end
+        end
+
+        begin
+          runner = Runner.new(nil)
+          runner.run
+        ensure
+          File.unlink(pid) if pid && File.exist?(pid)
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/util.rb

@@ -0,0 +1,274 @@
+module MCollective
+  # Some basic utility helper methods useful to clients, agents, runner etc.
+  module Util
+    # Finds out if this MCollective has an agent by the name passed
+    #
+    # If the passed name starts with a / it's assumed to be regex
+    # and will use regex to match
+    def self.has_agent?(agent)
+      agent = Regexp.new(agent.gsub("\/", "")) if agent.match("^/")
+
+      if agent.is_a?(Regexp)
+        if Agents.agentlist.grep(agent).size > 0
+          return true
+        else
+          return false
+        end
+      else
+        return Agents.agentlist.include?(agent)
+      end
+
+      false
+    end
+
+    # On windows ^c can't interrupt the VM if its blocking on
+    # IO, so this sets up a dummy thread that sleeps and this
+    # will have the end result of being interruptable at least
+    # once a second.  This is a common pattern found in Rails etc
+    def self.setup_windows_sleeper
+      Thread.new { loop { sleep 1 } } if Util.windows?
+    end
+
+    # Checks if this node has a configuration management class by parsing the
+    # a text file with just a list of classes, recipes, roles etc.  This is
+    # ala the classes.txt from puppet.
+    #
+    # If the passed name starts with a / it's assumed to be regex
+    # and will use regex to match
+    def self.has_cf_class?(klass)
+      klass = Regexp.new(klass.gsub("\/", "")) if klass.match("^/")
+      cfile = Config.instance.classesfile
+
+      Log.debug("Looking for configuration management classes in #{cfile}")
+
+      begin
+        File.readlines(cfile).each do |k|
+          if klass.is_a?(Regexp)
+            return true if k.chomp.match(klass)
+          else
+            return true if k.chomp == klass
+          end
+        end
+      rescue Exception => e
+        Log.warn("Parsing classes file '#{cfile}' failed: #{e.class}: #{e}")
+      end
+
+      false
+    end
+
+    # Gets the value of a specific fact, mostly just a duplicate of MCollective::Facts.get_fact
+    # but it kind of goes with the other classes here
+    def self.get_fact(fact)
+      Facts.get_fact(fact)
+    end
+
+    # Compares fact == value,
+    #
+    # If the passed value starts with a / it's assumed to be regex
+    # and will use regex to match
+    def self.has_fact?(fact, value, operator)
+
+      Log.debug("Comparing #{fact} #{operator} #{value}")
+      Log.debug("where :fact = '#{fact}', :operator = '#{operator}', :value = '#{value}'")
+
+      fact = Facts[fact]
+      return false if fact.nil?
+
+      fact = fact.clone
+
+      if operator == '=~'
+        # to maintain backward compat we send the value
+        # as /.../ which is what 1.0.x needed.  this strips
+        # off the /'s wich is what we need here
+        if value =~ /^\/(.+)\/$/
+          value = $1
+        end
+
+        return true if fact.match(Regexp.new(value))
+
+      elsif operator == "=="
+        return true if fact == value
+
+      elsif ['<=', '>=', '<', '>', '!='].include?(operator)
+        # Yuk - need to type cast, but to_i and to_f are overzealous
+        if value =~ /^[0-9]+$/ && fact =~ /^[0-9]+$/
+          fact = Integer(fact)
+          value = Integer(value)
+        elsif value =~ /^[0-9]+.[0-9]+$/ && fact =~ /^[0-9]+.[0-9]+$/
+          fact = Float(fact)
+          value = Float(value)
+        end
+
+        return true if eval("fact #{operator} value")
+      end
+
+      false
+    end
+
+    # Checks if the configured identity matches the one supplied
+    #
+    # If the passed name starts with a / it's assumed to be regex
+    # and will use regex to match
+    def self.has_identity?(identity)
+      identity = Regexp.new(identity.gsub("\/", "")) if identity.match("^/")
+
+      if identity.is_a?(Regexp)
+        return Config.instance.identity.match(identity)
+      else
+        return true if Config.instance.identity == identity
+      end
+
+      false
+    end
+
+    # Checks if the passed in filter is an empty one
+    def self.empty_filter?(filter)
+      filter == empty_filter || filter == {}
+    end
+
+    # Creates an empty filter
+    def self.empty_filter
+      {"fact"     => [],
+        "cf_class" => [],
+        "agent"    => [],
+        "identity" => [],
+        "compound" => []}
+    end
+
+    # Picks a config file defaults to ~/.mcollective
+    # else /etc/mcollective/client.cfg
+    def self.config_file_for_user
+      # expand_path is pretty lame, it relies on HOME environment
+      # which isnt't always there so just handling all exceptions
+      # here as cant find reverting to default
+      begin
+        config = File.expand_path("~/.mcollective")
+
+        unless File.readable?(config) && File.file?(config)
+          config = "/etc/mcollective/client.cfg"
+        end
+      rescue Exception => e
+        config = "/etc/mcollective/client.cfg"
+      end
+
+      return config
+    end
+
+    # Creates a standard options hash
+    def self.default_options
+      {:verbose     => false,
+        :disctimeout => 2,
+        :timeout     => 5,
+        :config      => config_file_for_user,
+        :collective  => nil,
+        :filter      => empty_filter}
+    end
+
+    def self.make_subscriptions(agent, type, collective=nil)
+      config = Config.instance
+
+      raise("Unknown target type #{type}") unless [:broadcast, :directed, :reply].include?(type)
+
+      if collective.nil?
+        config.collectives.map do |c|
+          {:agent => agent, :type => type, :collective => c}
+        end
+      else
+        raise("Unknown collective '#{collective}' known collectives are '#{config.collectives.join ', '}'") unless config.collectives.include?(collective)
+
+        [{:agent => agent, :type => type, :collective => collective}]
+      end
+    end
+
+    # Helper to subscribe to a topic on multiple collectives or just one
+    def self.subscribe(targets)
+      connection = PluginManager["connector_plugin"]
+
+      targets = [targets].flatten
+
+      targets.each do |target|
+        connection.subscribe(target[:agent], target[:type], target[:collective])
+      end
+    end
+
+    # Helper to unsubscribe to a topic on multiple collectives or just one
+    def self.unsubscribe(targets)
+      connection = PluginManager["connector_plugin"]
+
+      targets = [targets].flatten
+
+      targets.each do |target|
+        connection.unsubscribe(target[:agent], target[:type], target[:collective])
+      end
+    end
+
+    # Wrapper around PluginManager.loadclass
+    def self.loadclass(klass)
+      PluginManager.loadclass(klass)
+    end
+
+    # Parse a fact filter string like foo=bar into the tuple hash thats needed
+    def self.parse_fact_string(fact)
+      if fact =~ /^([^ ]+?)[ ]*=>[ ]*(.+)/
+        return {:fact => $1, :value => $2, :operator => '>=' }
+      elsif fact =~ /^([^ ]+?)[ ]*=<[ ]*(.+)/
+        return {:fact => $1, :value => $2, :operator => '<=' }
+      elsif fact =~ /^([^ ]+?)[ ]*(<=|>=|<|>|!=|==|=~)[ ]*(.+)/
+        return {:fact => $1, :value => $3, :operator => $2 }
+      elsif fact =~ /^(.+?)[ ]*=[ ]*\/(.+)\/$/
+        return {:fact => $1, :value => "/#{$2}/", :operator => '=~' }
+      elsif fact =~ /^([^= ]+?)[ ]*=[ ]*(.+)/
+        return {:fact => $1, :value => $2, :operator => '==' }
+      else
+        raise "Could not parse fact #{fact} it does not appear to be in a valid format"
+      end
+    end
+
+    # Escapes a string so it's safe to use in system() or backticks
+    #
+    # Taken from Shellwords#shellescape since it's only in a few ruby versions
+    def self.shellescape(str)
+      return "''" if str.empty?
+
+      str = str.dup
+
+      # Process as a single byte sequence because not all shell
+      # implementations are multibyte aware.
+      str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+
+      # A LF cannot be escaped with a backslash because a backslash + LF
+      # combo is regarded as line continuation and simply ignored.
+      str.gsub!(/\n/, "'\n'")
+
+      return str
+    end
+
+    def self.windows?
+      !!(RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i)
+    end
+
+    def self.eval_compound_statement(expression)
+      if expression.values.first =~ /^\//
+        return Util.has_cf_class?(expression.values.first)
+      elsif expression.values.first =~ />=|<=|=|<|>/
+        optype = expression.values.first.match(/>=|<=|=|<|>/)
+        name, value = expression.values.first.split(optype[0])
+        unless value.split("")[0] == "/"
+          optype[0] == "=" ? optype = "==" : optype = optype[0]
+        else
+          optype = "=~"
+        end
+
+        return Util.has_fact?(name,value, optype).to_s
+      else
+        return Util.has_cf_class?(expression.values.first)
+      end
+    end
+
+    # Returns the current ruby version as per RUBY_VERSION, mostly
+    # doing this here to aid testing
+    def self.ruby_version
+      RUBY_VERSION
+    end
+  end
+end

data/lib/mcollective/vendor.rb

@@ -0,0 +1,41 @@
+module MCollective
+  # Simple module to manage vendored code.
+  #
+  # To vendor a library simply download its whole git repo or untar
+  # into vendor/libraryname and create a load_libraryname.rb file
+  # to add its libdir into the $:.
+  #
+  # Once you have that file, add a require line in vendor/require_vendored.rb
+  # which will run after all the load_* files.
+  #
+  # The intention is to not change vendored libraries and to eventually
+  # make adding them in optional so that distros can simply adjust their
+  # packaging to exclude this directory and the various load_xxx.rb scripts
+  # if they wish to install these gems as native packages.
+  class Vendor
+    class << self
+      def vendor_dir
+        File.join([File.dirname(File.expand_path(__FILE__)), "vendor"])
+      end
+
+      def load_entry(entry)
+        Log.debug("Loading vendored #{$1}")
+        load "#{vendor_dir}/#{entry}"
+      end
+
+      def require_libs
+        require 'mcollective/vendor/require_vendored'
+      end
+
+      def load_vendored
+        Dir.entries(vendor_dir).each do |entry|
+          if entry.match(/load_(\w+?)\.rb$/)
+            load_entry entry
+          end
+        end
+
+        require_libs
+      end
+    end
+  end
+end

data/lib/mcollective/vendor/require_vendored.rb

@@ -0,0 +1,2 @@
+require 'systemu'
+require 'json'

data/lib/mcollective/windows_daemon.rb

@@ -0,0 +1,25 @@
+require 'win32/daemon'
+
+module MCollective
+  class WindowsDaemon < Win32::Daemon
+    def self.daemonize_runner(pid=nil)
+      raise "Writing pid files are not supported on the Windows Platform" if pid
+      raise "The Windows Daemonizer should only be used on the Windows Platform" unless Util.windows?
+
+      WindowsDaemon.mainloop
+    end
+
+    def service_main
+      Log.debug("Starting Windows Service Daemon")
+
+      runner = Runner.new(nil)
+      runner.run
+    end
+
+    def service_stop
+      Log.info("Windows service stopping")
+      PluginManager["connector_plugin"].disconnect
+      exit! 0
+    end
+  end
+end

data/spec/Rakefile

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:all) do |t|
+    t.pattern = 'unit/**/*_spec.rb'
+
+    if MCollective::Util.windows?
+      t.rspec_opts = File.read("windows_spec.opts").chomp
+    else
+      t.rspec_opts = File.read("spec.opts").chomp
+    end
+end
+
+task :default => [:all]

data/spec/fixtures/application/test.rb

@@ -0,0 +1,7 @@
+module MCollective
+  class Application::Test < Application
+    def run
+      true
+    end
+  end
+end

data/spec/fixtures/test-cert.pem

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICRDCCAa2gAwIBAgIBAjANBgkqhkiG9w0BAQUFADAfMR0wGwYDVQQDDBRQdXBw
+ZXQgQ0E6IGRldmNvLm5ldDAeFw0xMjAzMzAyMTQ2NDRaFw0xNzAzMjkyMTQ2NDRa
+MA4xDDAKBgNVBAMMA2ZvbzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0X8t
+vvXk9Tmfhw5T87svZ1Oc2xORR1YbPTBCpNR3dvg2Pdurt16dLMXIGT5EeXkZy6cF
+MHG9pg/0ubCA7L/EdPI/Xq6n+O2kUUX8+ca0qwmj9/TwqxMSxVlKGr6SSqcCcHfi
+0hsDsHQaKyzAPbr69gbHhBzskd9bkh51Tyg96JECAwEAAaOBoDCBnTA4BglghkgB
+hvhCAQ0EKxYpUHVwcGV0IFJ1YnkvT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNh
+dGUwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUjZoFfKlgsGXuldlQQPOnBNrX9oMw
+CwYDVR0PBAQDAgWgMCcGA1UdJQQgMB4GCCsGAQUFBwMBBggrBgEFBQcDAgYIKwYB
+BQUHAwQwDQYJKoZIhvcNAQEFBQADgYEApfZYKcYrMUtStJ0jjoZryn4ssghs8mkl
+C+njqTt/X8/7drqiSHB/0WXN0366QfVEgotxh0akhi2GJxs+eD/iCIRSL29hwDjL
+LpcsM/Rk0s8jG/XJDmS+BdY+wGOezasaCaqQlsU/Sjv8TQ+8D89OBfh+ZYW3gL9E
+JWp47gFO/RA=
+-----END CERTIFICATE-----

data/spec/fixtures/test-private.pem

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDMMGfwPZO8Xwn8XvrOy3Nc4nTkY/8lJrF3wvoGWdrcuQsNjYvZ
+O59PqXGxu/No5Lt5ymMd8orxR3bPRy2uobmZ2yXPP5mh48lZkMazGHPUeZkWOWbR
+7hgAvOVpNGp6NyR7D3PxZ96jzAbH8ttJVZAt/T2ImMJrzUG1Oj0/XO9fNQIDAQAB
+AoGALnA/41KN3ASdZ8lOL2P0C8bxINRhPdjL+dndNT6QWSy4h8+OY8x8kgiOdAaz
++EI1JSDTZAc6dF91dPTSPepIJH5n+ueBDHFTGUnbxCw25+6X9CaLig52fNh7vs53
+sjtEvpju4Qe49FjnGe+UZ6jhd5b10pFtiuTVhMUTE77HqmECQQD4iSmj5/OVz3qk
+zrJ9Z8z6NjQFjklA1reHWhYal9k+475xOyLQz4yXk+pzq+9uYMo+LBIvDaY+mzDb
+I3Sp8/vJAkEA0lJKANLqkRsGqp2BITzFS3vpoYQxL13pghFfvQPkpD+JbHB0wI4a
+E1xv1kr/4bQ3aMEohJnaLbAf/O20nS3mDQJBAOwZ0Tbl+J7OlSHPQfykCTOBHnZQ
+rwIrd/na+LiWnEiELbx/gxl+sX6lg8oTAceHp1jcoQGWI+HBp+3lhsSVBRECQHz2
+jae9qcc7kpNu79lqvSLjZeYkoACvwN0aK5MnrAL3CVTX4FbEV7PnOT/O4ggdxspD
+8ioPK7X3rpneNnEpY0UCQQCM38gg75soJTS9W3BY04gLdjLd1h5rXe28bTgnwRM2
+Y2HMzPDtCWdjWvmpZMfAg+U4Rkr24Gbd1V3bq6OlJIeB
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/test-public.pem

@@ -0,0 +1,6 @@
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDMMGfwPZO8Xwn8XvrOy3Nc4nTk
+Y/8lJrF3wvoGWdrcuQsNjYvZO59PqXGxu/No5Lt5ymMd8orxR3bPRy2uobmZ2yXP
+P5mh48lZkMazGHPUeZkWOWbR7hgAvOVpNGp6NyR7D3PxZ96jzAbH8ttJVZAt/T2I
+mMJrzUG1Oj0/XO9fNQIDAQAB
+-----END PUBLIC KEY-----