choria-mcorpc-support 2.22.0 → 2.23.2

data/lib/mcollective/applications.rb

@@ -12,11 +12,11 @@ module MCollective
         load_application(appname)
       rescue Exception => e # rubocop:disable Lint/RescueException
         e.backtrace.first << Util.colorize(:red, "  <----")
-        STDERR.puts "Application '%s' failed to load:" % appname
-        STDERR.puts
-        STDERR.puts Util.colorize(:red, "   %s (%s)" % [$!, $!.class])
-        STDERR.puts
-        STDERR.puts "       %s" % [$!.backtrace.join("\n       ")]
+        warn "Application '%s' failed to load:" % appname
+        $stderr.puts
+        warn Util.colorize(:red, "   %s (%s)" % [$!, $!.class])
+        $stderr.puts
+        warn "       %s" % [$!.backtrace.join("\n       ")]
         exit 1
       end
 
@@ -40,7 +40,7 @@ module MCollective
     rescue SystemExit
       exit 1
     rescue Exception # rubocop:disable Lint/RescueException
-      STDERR.puts("Failed to generate application list: %s: %s" % [$!.class, $!])
+      warn("Failed to generate application list: %s: %s" % [$!.class, $!])
       exit 1
     end
 
@@ -49,13 +49,14 @@ module MCollective
     def self.filter_extra_options(opts)
       words = Shellwords.shellwords(opts)
       words.each_with_index do |word, idx|
-        if word == "-c"
+        case word
+        when "-c"
           return "--config=#{words[idx + 1]}"
-        elsif word == "--config"
+        when "--config"
           return "--config=#{words[idx + 1]}"
-        elsif word =~ /\-c=/
+        when /-c=/
           return word
-        elsif word =~ /\-\-config=/
+        when /--config=/
           return word
         end
       end

data/lib/mcollective/audit/choria.rb

@@ -0,0 +1,33 @@
+module MCollective
+  module Audit
+    class Choria < RPC::Audit
+      def audit_request(request, connection)
+        logfile = Config.instance.pluginconf["rpcaudit.logfile"]
+
+        unless logfile
+          Log.warn("Auditing is not functional because rpcaudit.logfile is not set")
+          return
+        end
+
+        message = {
+          "timestamp" => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%6N%z"),
+          "request_id" => request.uniqid,
+          "request_time" => request.time,
+          "caller" => request.caller,
+          "sender" => request.sender,
+          "agent" => request.agent,
+          "action" => request.action,
+          "data" => request.data
+        }
+
+        begin
+          File.open(logfile, "a") do |f|
+            f.puts(message.to_json)
+          end
+        rescue
+          Log.warn("Auditing is not functional because writing to logfile '%s' failed %s: %s" % [logfile, $!.class, $!.to_s])
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/cache.rb

@@ -122,14 +122,12 @@ module MCollective
       end
     end
 
-    def self.synchronize(cache_name)
+    def self.synchronize(cache_name, &block)
       raise("No cache called '%s'" % cache_name) unless @cache.include?(cache_name)
 
       raise("No block supplied to synchronize") unless block_given?
 
-      @cache_locks[cache_name].synchronize do
-        yield
-      end
+      @cache_locks[cache_name].synchronize(&block)
     end
 
     def self.invalidate!(cache_name, key)

data/lib/mcollective/client.rb

@@ -7,10 +7,11 @@ module MCollective
       @config = Config.instance
       @options = nil
 
-      if options.is_a?(String)
+      case options
+      when String
         # String is the path to a config file
         @config.loadconfig(options) unless @config.configured
-      elsif options.is_a?(Hash)
+      when Hash
         @config.loadconfig(options[:config]) unless @config.configured
         @options = options
         @connection_timeout = options[:connection_timeout]
@@ -43,6 +44,10 @@ module MCollective
 
     @@request_sequence = 0 # rubocop:disable Style/ClassVars
 
+    def self.reset_request_sequence
+      @@request_sequence = 0 # rubocop:disable Style/ClassVars
+    end
+
     def self.request_sequence
       @@request_sequence
     end
@@ -124,9 +129,7 @@ module MCollective
 
         reply.decode!
 
-        unless reply.requestid == requestid
-          raise(MsgDoesNotMatchRequestID, "Message reqid #{reply.requestid} does not match our reqid #{requestid}")
-        end
+        raise(MsgDoesNotMatchRequestID, "Message reqid #{reply.requestid} does not match our reqid #{requestid}") unless reply.requestid == requestid
 
         Log.debug("Received reply to #{reply.requestid} from #{reply.payload[:senderid]}")
       rescue SecurityValidationFailed => e
@@ -171,7 +174,7 @@ module MCollective
       request = createreq(body, agent, @options[:filter])
       publish_timeout = @options[:publish_timeout] || @config.publish_timeout
       stat = {:starttime => Time.now.to_f, :discoverytime => 0, :blocktime => 0, :totaltime => 0}
-      STDOUT.sync = true
+      $stdout.sync = true
       hosts_responded = 0
 
       begin
@@ -180,7 +183,7 @@ module MCollective
         else
           hosts_responded = unthreaded_req(request, publish_timeout, timeout, waitfor, &block)
         end
-      rescue Interrupt # rubocop:disable Lint/HandleExceptions
+      rescue Interrupt # rubocop:disable Lint/SuppressedException
       ensure
         unsubscribe(agent, :reply)
       end
@@ -277,9 +280,7 @@ module MCollective
         end
       rescue Timeout::Error
         if waitfor.is_a?(Array)
-          unless unfinished.empty?
-            Log.warn("Could not receive all responses. Did not receive responses from #{unfinished.keys.join(', ')}")
-          end
+          Log.warn("Could not receive all responses. Did not receive responses from #{unfinished.keys.join(', ')}") unless unfinished.empty?
         elsif waitfor > hosts_responded
           Log.warn("Could not receive all responses. Expected : #{waitfor}. Received : #{hosts_responded}")
         end

data/lib/mcollective/config.rb

@@ -5,19 +5,13 @@ module MCollective
 
     attr_accessor :mode
 
-    attr_reader :daemonize, :pluginconf, :configured
-    attr_reader :logfile, :keeplogs, :max_log_size, :loglevel, :logfacility
-    attr_reader :identity, :connector, :securityprovider, :factsource
-    attr_reader :registration, :registerinterval, :classesfile
-    attr_reader :rpcauditprovider, :rpcaudit, :configdir, :rpcauthprovider
-    attr_reader :rpcauthorization, :color, :configfile
-    attr_reader :rpclimitmethod, :logger_type, :fact_cache_time, :collectives
-    attr_reader :main_collective, :ssl_cipher, :registration_collective
-    attr_reader :direct_addressing, :direct_addressing_threshold, :ttl
-    attr_reader :default_discovery_method, :default_discovery_options
-    attr_reader :publish_timeout, :threaded, :soft_shutdown, :activate_agents
-    attr_reader :registration_splay, :discovery_timeout, :soft_shutdown_timeout
-    attr_reader :connection_timeout, :default_batch_size, :default_batch_sleep_time
+    attr_reader :daemonize, :pluginconf, :configured, :logfile, :keeplogs, :max_log_size, :loglevel, :logfacility,
+                :identity, :connector, :securityprovider, :factsource, :registration, :registerinterval, :classesfile,
+                :rpcauditprovider, :rpcaudit, :configdir, :rpcauthprovider, :rpcauthorization, :color, :configfile,
+                :rpclimitmethod, :logger_type, :fact_cache_time, :collectives, :main_collective, :ssl_cipher, :registration_collective,
+                :direct_addressing, :direct_addressing_threshold, :ttl, :default_discovery_method, :default_discovery_options,
+                :publish_timeout, :threaded, :soft_shutdown, :activate_agents, :registration_splay, :discovery_timeout, :soft_shutdown_timeout,
+                :connection_timeout, :default_batch_size, :default_batch_sleep_time
 
     def initialize
       @configured = false
@@ -34,19 +28,12 @@ module MCollective
 
           next if line =~ /^#|^$/
           next unless line =~ /(.+?)\s*=\s*(.+)/
+
           key = $1.strip
           val = $2
 
           begin
             case key
-            when "registration"
-              @registration = val.capitalize
-            when "registration_collective"
-              @registration_collective = val
-            when "registerinterval"
-              @registerinterval = Integer(val)
-            when "registration_splay"
-              @registration_splay = Util.str_to_bool(val)
             when "collectives"
               @collectives = val.split(",").map(&:strip)
             when "main_collective"
@@ -128,10 +115,11 @@ module MCollective
               @default_batch_size = Integer(val)
             when "default_batch_sleep_time"
               @default_batch_sleep_time = Float(val)
-            when "topicprefix", "topicsep", "queueprefix", "rpchelptemplate", "helptemplatedir"
-              Log.warn("Use of deprecated '#{key}' option.  This option is ignored and should be removed from '#{configfile}'")
             else
-              raise("Unknown config parameter '#{key}'")
+              # server config might now be choria config which will divirge from mcollective
+              # in time, so we only raise this error when it looks like we aren't loading
+              # a server config else we try our best to load as much as we can
+              raise("Unknown config parameter '#{key}'") unless configfile =~ /server/
             end
           rescue ArgumentError
             raise("Could not parse value for configuration option '%s' with value '%s'" % [key, val])
@@ -140,7 +128,7 @@ module MCollective
 
         read_plugin_config_dir("#{@configdir}/plugin.d")
 
-        raise 'Identities can only match /\w\.\-/' unless @identity =~ /^[\w\.\-]+$/
+        raise 'Identities can only match /\w\.\-/' unless @identity =~ /^[\w.\-]+$/
 
         @configured = true
 
@@ -152,14 +140,13 @@ module MCollective
           $LOAD_PATH.unshift dir
         end
 
-        if @logger_type == "syslog"
-          raise "The sylog logger is not usable on the Windows platform" if Util.windows?
-        end
+        raise "The sylog logger is not usable on the Windows platform" if @logger_type == "syslog" && Util.windows?
 
-        PluginManager.loadclass("Mcollective::Facts::#{@factsource}_facts")
-        PluginManager.loadclass("Mcollective::Connector::#{@connector}")
-        PluginManager.loadclass("Mcollective::Security::#{@securityprovider}")
-        PluginManager << {:type => "global_stats", :class => RunnerStats.new}
+        unless configfile =~ /server/
+          PluginManager.loadclass("Mcollective::Facts::#{@factsource}_facts")
+          PluginManager.loadclass("Mcollective::Connector::#{@connector}")
+          PluginManager.loadclass("Mcollective::Security::#{@securityprovider}")
+        end
 
         Log.info("The Marionette Collective version #{MCollective::VERSION} started by #{$0} using config file #{configfile}")
       else
@@ -168,7 +155,6 @@ module MCollective
     end
 
     def set_config_defaults(configfile) # rubocop:disable Naming/AccessorMethodName
-      @stomp = {}
       @subscribe = []
       @pluginconf = {}
       @connector = "base"
@@ -221,7 +207,7 @@ module MCollective
       return unless File.directory?(dir)
 
       Dir.new(dir).each do |pluginconfigfile|
-        next unless pluginconfigfile =~ /^([\w]+).cfg$/
+        next unless pluginconfigfile =~ /^(\w+).cfg$/
 
         plugin = $1
         File.open("#{dir}/#{pluginconfigfile}", "r").each do |line|
@@ -229,6 +215,7 @@ module MCollective
           line.gsub!(/\s*$/, "")
           next if line =~ /^#|^$/
           next unless line =~ /(.+?)\s*=\s*(.+)/
+
           key = $1.strip
           val = $2
           @pluginconf["#{plugin}.#{key}"] = val

data/lib/mcollective/connector/base.rb

@@ -18,8 +18,9 @@ module MCollective
     class Base
       def self.inherited(klass)
         plugin_name = klass.to_s.split("::").last.downcase
-        ddl = DDL.new(plugin_name, :connector)
+        DDL.new(plugin_name, :connector)
         PluginManager << {:type => "connector_plugin", :class => klass.to_s}
+        super
       end
     end
   end

data/lib/mcollective/connector/nats.ddl

@@ -0,0 +1,9 @@
+metadata    :name        => "nats",
+            :description => "Connector plugin for NATS.io middleware",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "Apache-2.0",
+            :version     => "0.19.0",
+            :url         => "https://github.com/choria-io",
+            :timeout     => 60
+
+requires :mcollective => "2.8.4"

data/lib/mcollective/connector/nats.rb

@@ -0,0 +1,450 @@
+require "resolv"
+require_relative "../util/choria"
+require_relative "../util/natswrapper"
+
+module MCollective
+  module Connector
+    class Nats < Base
+      attr_reader :connection
+
+      def initialize # rubocop:disable Lint/MissingSuper
+        @config = Config.instance
+        @subscriptions = []
+        @connection = Util::NatsWrapper.new
+
+        Log.info("Choria NATS.io connector using pure ruby nats/io/client %s with protocol version %s" % [NATS::IO::VERSION, NATS::IO::PROTOCOL])
+      end
+
+      # Determines if the NATS connection is active
+      #
+      # @return [Boolean]
+      def connected?
+        connection.connected?
+      end
+
+      # Current connected server
+      #
+      # @return [String,nil]
+      def connected_server
+        connection.connected_server
+      end
+
+      # Retrieves the NATS connection stats
+      #
+      # @return [Hash]
+      def stats
+        connection.stats
+      end
+
+      # Client library version
+      #
+      # @return [String]
+      def client_version
+        connection.client_version
+      end
+
+      # Client library flavour
+      #
+      # @return [String]
+      def client_flavour
+        connection.client_flavour
+      end
+
+      # Connection options from the NATS gem
+      #
+      # @return [Hash]
+      def active_options
+        connection.active_options
+      end
+
+      # Attempts to connect to the middleware, noop when already connected
+      #
+      # @return [void]
+      # @raise [StandardError] when SSL files are not readable
+      def connect
+        if connection && connection.started?
+          Log.debug("Already connection, not re-initializing connection")
+          return
+        end
+
+        parameters = {
+          :max_reconnect_attempts => -1,
+          :reconnect_time_wait => 1,
+          :dont_randomize_servers => !choria.randomize_middleware_servers?,
+          :name => @config.identity
+        }
+
+        parameters[:user_credentials] = choria.credential_file if choria.credential_file?
+
+        if $choria_unsafe_disable_nats_tls # rubocop:disable Style/GlobalVars
+          Log.warn("Disabling TLS in NATS connector, this is not a production supported setup")
+        elsif choria.ngs?
+          configure_ngs(parameters)
+        else
+          configure_tls(parameters)
+        end
+
+        servers = server_list
+
+        unless servers.empty?
+          Log.debug("Connecting to servers: %s" % servers.join(", "))
+          parameters[:servers] = servers
+        end
+
+        connection.start(parameters)
+
+        nil
+      end
+
+      def configure_tls(parameters)
+        parameters[:tls] = {:context => choria.ssl_context}
+        choria.check_ssl_setup
+      end
+
+      def configure_ngs(parameters)
+        Log.debug("Disabling specific TLS during connection to NGS")
+
+        raise("nkeys rubygem is required for connections with credentials") unless choria.nkeys?
+
+        tls = OpenSSL::SSL::SSLContext.new
+        tls.ssl_version = :TLSv1_2 # rubocop:disable Naming/VariableNumber
+
+        parameters[:tls] = {:context => tls}
+      end
+
+      # Disconnects from NATS
+      def disconnect
+        connection.stop
+      end
+
+      # Creates the middleware headers needed for a given message
+      #
+      # @param msg [Message]
+      # @return [Hash]
+      def headers_for(msg)
+        # mc_sender is only passed bacause M::Message incorrectly assumed this is some required
+        # part of messages when its just some internals of the stomp based connectors that bled out
+        headers = {
+          "mc_sender" => @config.identity
+        }
+
+        headers["seen-by"] = [] if msg.headers.include?("seen-by")
+
+        if [:request, :direct_request].include?(msg.type)
+          if msg.reply_to
+            headers["reply-to"] = msg.reply_to
+          else
+            # if its a request/direct_request style message and its not
+            # one we're replying to - ie. its a new message we're making
+            # we'll need to set a reply-to target that the daemon will
+            # subscribe to
+            headers["reply-to"] = make_target(msg.agent, :reply, msg.collective)
+          end
+
+          headers["seen-by"] << [@config.identity, connected_server.to_s] if msg.headers.include?("seen-by")
+        elsif msg.type == :reply
+          if msg.request.headers.include?("seen-by")
+            headers["seen-by"] = msg.request.headers["seen-by"]
+            headers["seen-by"].last << connected_server.to_s
+          end
+        end
+
+        headers
+      end
+
+      # Create a target structure for a message
+      #
+      # @example data
+      #
+      #     {
+      #       :name => "nats.name",
+      #       :headers => { headers... }
+      #     }
+      #
+      # @param msg [Message]
+      # @param identity [String,nil] override identity
+      # @return [Hash]
+      def target_for(msg, identity=nil)
+        target = nil
+
+        if msg.type == :reply
+          raise("Do not know how to reply, no reply-to header has been set on message %s" % msg.requestid) unless msg.request.headers["reply-to"]
+
+          target = {:name => msg.request.headers["reply-to"], :headers => {}}
+
+        elsif [:request, :direct_request].include?(msg.type)
+          target = {:name => make_target(msg.agent, msg.type, msg.collective, identity), :headers => {}}
+
+        else
+          raise("Don't now how to create a target for message type %s" % msg.type)
+
+        end
+
+        target[:headers].merge!(headers_for(msg))
+
+        target
+      end
+
+      # Retrieves the current process pid
+      #
+      # @note mainly used for testing
+      # @return [Fixnum]
+      def current_pid
+        $$
+      end
+
+      # Creates a target structure
+      #
+      # @param agent [String] agent name
+      # @param type [:directed, :broadcast, :reply, :request, :direct_request]
+      # @param collective [String] target collective name
+      # @param identity [String,nil] identity for the request, else node configured identity
+      # @return [String] target name
+      # @raise [StandardError] on invalid input
+      def make_target(agent, type, collective, identity=nil)
+        raise("Unknown target type %s" % type) unless [:directed, :broadcast, :reply, :request, :direct_request].include?(type)
+
+        raise("Unknown collective '%s' known collectives are '%s'" % [collective, @config.collectives.join(", ")]) unless @config.collectives.include?(collective)
+
+        identity ||= @config.identity
+
+        case type
+        when :reply
+          "%s.reply.%s.%d.%d" % [collective, Digest::MD5.hexdigest(choria.callerid), current_pid, Client.request_sequence]
+
+        when :broadcast, :request
+          "%s.broadcast.agent.%s" % [collective, agent]
+
+        when :direct_request, :directed
+          "%s.node.%s" % [collective, identity]
+        end
+      end
+
+      # Publishes a message to the middleware
+      #
+      # @param msg [Message]
+      def publish(msg)
+        msg.base64_encode!
+
+        if choria.federated?
+          msg.type == :direct_request ? publish_federated_directed(msg) : publish_federated_broadcast(msg)
+        else
+          msg.type == :direct_request ? publish_connected_directed(msg) : publish_connected_broadcast(msg)
+        end
+      end
+
+      # Publish a directed request via a Federation Broker
+      #
+      # @param msg [Message]
+      def publish_federated_directed(msg)
+        messages = []
+        target = target_for(msg, msg.discovered_hosts[0])
+
+        msg.discovered_hosts.in_groups_of(200) do |nodes|
+          node_targets = nodes.compact.map do |node|
+            target_for(msg, node)[:name]
+          end
+
+          data = {
+            "protocol" => "choria:transport:1",
+            "data" => msg.payload,
+            "headers" => {
+              "federation" => {
+                "target" => node_targets,
+                "req" => msg.requestid
+              }
+            }.merge(target[:headers])
+          }
+
+          messages << JSON.dump(data)
+        end
+
+        choria.federation_collectives.each do |network|
+          messages.each do |data|
+            network_target = "choria.federation.%s.federation" % network
+
+            Log.debug("Sending a federated direct message via NATS target '%s' for message type %s" % [network_target, msg.type])
+
+            connection.publish(network_target, data, target[:headers]["reply-to"])
+          end
+        end
+      end
+
+      # Publish a directed request to a connected collective
+      #
+      # @param msg [Message]
+      def publish_connected_directed(msg)
+        msg.discovered_hosts.each do |node|
+          target = target_for(msg, node)
+          data = {
+            "protocol" => "choria:transport:1",
+            "data" => msg.payload,
+            "headers" => target[:headers]
+          }
+
+          Log.debug("Sending a direct message to %s via NATS target '%s' for message type %s" % [node, target.inspect, msg.type])
+
+          connection.publish(target[:name], data.to_json, target[:headers]["reply-to"])
+        end
+      end
+
+      # Publish a broadcast message to via a Federation Broker
+      #
+      # @param msg [Message]
+      def publish_federated_broadcast(msg)
+        target = target_for(msg)
+        data = {
+          "protocol" => "choria:transport:1",
+          "data" => msg.payload,
+          "headers" => {
+            "federation" => {
+              "target" => [target[:name]],
+              "req" => msg.requestid
+            }
+          }.merge(target[:headers])
+        }
+
+        data = JSON.dump(data)
+
+        choria.federation_collectives.each do |network|
+          target[:name] = "choria.federation.%s.federation" % network
+
+          Log.debug("Sending a federated broadcast message to NATS target '%s' for message type %s" % [target.inspect, msg.type])
+
+          connection.publish(target[:name], data, target[:headers]["reply-to"])
+        end
+      end
+
+      # Publish a broadcast message to a connected collective
+      #
+      # @param msg [Message]
+      def publish_connected_broadcast(msg)
+        target = target_for(msg)
+        data = {
+          "protocol" => "choria:transport:1",
+          "data" => msg.payload,
+          "headers" => target[:headers]
+        }
+
+        # only happens when replying
+        received_message = msg.request
+        data["headers"]["federation"] = received_message.headers["federation"] if received_message && received_message.headers.include?("federation")
+
+        Log.debug("Sending a broadcast message to NATS target '%s' for message type %s" % [target.inspect, msg.type])
+
+        connection.publish(target[:name], JSON.dump(data), target[:headers]["reply-to"])
+      end
+
+      # Unsubscribe from the target for a agent
+      #
+      # @see make_target
+      # @param agent [String] agent name
+      # @param type [:reply, :broadcast, :request, :direct_request, :directed] type of message you want a subscription for
+      # @param collective [String] the collective to subscribe for
+      # @return [void]
+      def unsubscribe(agent, type, collective)
+        target = make_target(agent, type, collective)
+        Log.debug("Unsubscribing from %s" % target)
+
+        connection.unsubscribe(target)
+      end
+
+      # Subscribes to the topics/queues needed for a particular agent
+      #
+      # @see make_target
+      # @param agent [String] agent name
+      # @param type [:reply, :broadcast, :request, :direct_request, :directed] type of message you want a subscription for
+      # @param collective [String] the collective to subscribe for
+      # @return [void]
+      def subscribe(agent, type, collective)
+        target = make_target(agent, type, collective)
+
+        connection.subscribe(target)
+      end
+
+      # Receives a message from the middleware
+      #
+      # @note blocks until one is received
+      # @return [Message]
+      def receive
+        msg = nil
+
+        until msg
+          received = connection.receive
+
+          Thread.pass
+
+          begin
+            msg = JSON.parse(received)
+          rescue
+            Log.warn("Got non JSON data from the broker: %s" % [received])
+            msg = nil
+          end
+        end
+
+        msg["headers"]["seen-by"] << [connected_server.to_s, @config.identity] if msg["headers"].include?("seen-by")
+
+        Message.new(msg["data"], msg, :base64 => true, :headers => msg["headers"])
+      end
+
+      # Retrieves the list of server and port combos to attempt to connect to
+      #
+      # Configured servers are checked, then SRV records and finally a fall
+      # back to puppet:4222 is done
+      #
+      # @return [Array<String>] list of servers in form of a URI
+      def server_list
+        uris = choria.middleware_servers("puppet", "4222").map do |host, port|
+          URI("nats://%s:%s" % [host, port])
+        end
+
+        decorate_servers_with_users(uris).map(&:to_s)
+      end
+
+      # Add user and pass to a series of URIs
+      #
+      # @param servers [Array<URI>] list of URI's to decorate
+      # @return [Array<URI>]
+      def decorate_servers_with_users(servers)
+        user = get_option("nats.user", environment["MCOLLECTIVE_NATS_USERNAME"])
+        pass = get_option("nats.pass", environment["MCOLLECTIVE_NATS_PASSWORD"])
+
+        if choria.anon_tls?
+          user = PluginManager["security_plugin"].request_signer.token
+          pass = nil
+        end
+
+        if user || pass
+          servers.each do |uri|
+            uri.user = user
+            uri.password = pass
+          end
+        end
+
+        servers
+      end
+
+      # Retrieves the environment, mainly used for testing
+      def environment
+        ENV
+      end
+
+      # Gets a config option
+      #
+      # @param opt [String] config option to look up
+      # @param default [Object] default to return when not found
+      # @return [Object] the found data or default
+      # @raise [StandardError] when no default is given and option is not found
+      def get_option(opt, default=:_unset)
+        return @config.pluginconf[opt] if @config.pluginconf.include?(opt)
+        return default unless default == :_unset
+
+        raise("No plugin.%s configuration option given" % opt)
+      end
+
+      def choria
+        @_choria ||= Util::Choria.new(false)
+      end
+    end
+  end
+end