cloud-mu 1.9.0.pre.beta

data/modules/mu/groomer.rb

@@ -0,0 +1,123 @@
+# Copyright:: Copyright (c) 2014 eGlobalTech, Inc., all rights reserved
+#
+# Licensed under the BSD-3 license (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the root of the project or at
+#
+#     http://egt-labs.com/mu/LICENSE.html
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module MU
+  # Plugins under this namespace serve as interfaces to configuration
+  # management tools (Chef, Puppet, etc).
+  class Groomer
+
+    # An exception denoting a Groomer run that has failed
+    class RunError < MuError;
+    end
+
+    # List of known/supported grooming agents (configuration management tools)
+    def self.supportedGroomers
+      ["Chef"]
+    end
+
+    # Instance methods that any Groomer plugin must implement
+    def self.requiredMethods
+      [:preClean, :bootstrap, :haveBootstrapped?, :run, :saveDeployData, :getSecret, :saveSecret, :deleteSecret, :reinstall]
+    end
+
+    # Class methods that any Groomer plugin must implement
+    def self.requiredClassMethods
+      [:getSecret, :cleanup, :saveSecret, :deleteSecret]
+    end
+
+
+    class Chef;
+    end
+    # @param groomer [String]: The grooming agent to load.
+    # @return [Class]: The class object implementing this groomer agent
+    def self.loadGroomer(groomer)
+      if !File.size?(MU.myRoot+"/modules/mu/groomers/#{groomer.downcase}.rb")
+        raise MuError, "Requested to use unsupported grooming agent #{groomer}"
+      end
+      require "mu/groomers/#{groomer.downcase}"
+      myclass = Object.const_get("MU").const_get("Groomer").const_get(groomer)
+      MU::Groomer.requiredMethods.each { |method|
+        if !myclass.public_instance_methods.include?(method)
+          raise MuError, "MU::Groom::#{groomer} has not implemented required instance method #{method}"
+        end
+      }
+      MU::Groomer.requiredClassMethods.each { |method|
+        if !myclass.respond_to?(method)
+          raise MuError, "#{myclass} doesn't implement #{method}"
+        end
+      }
+
+      return myclass
+    end
+
+    attr_reader :groomer_obj
+    attr_reader :groomer_class
+
+    # @param server [MU::Cloud::Server]: The server which this groomer will be configuring.
+    def initialize(server)
+      @server = server
+      if !server.config.has_key?("groomer")
+        @groomer_class = MU::Groomer.loadGroomer(MU::Config.defaultGroomer)
+      else
+        @groomer_class = MU::Groomer.loadGroomer(server.config['groomer'])
+      end
+      @groom_semaphore = Mutex.new
+      @groom_locks = {}
+      @groomer_obj = @groomer_class.new(server)
+    end
+
+    # Wrapper for Groomer implementations of the cleanup class method. We'll
+    # helpfully provide the arguments we know the answer to.
+    def cleanup
+      raise MuError, "Called MU::Groomer.cleanup, but I don't have an instantiated server object to clean!" if @server.nil?
+      @groomer_class.cleanup(@server.mu_name, @server.config['vault_access'])
+    end
+
+    MU::Groomer.requiredMethods.each { |method|
+      define_method method do |*args|
+        retval = nil
+
+        # Go ahead and guarantee that we can't accidentally trigger these
+        # methods recursively.
+        @groom_semaphore.synchronize {
+          if @groom_locks.has_key?(method)
+            MU.log "Double-call to groomer method #{method} for #{@server}", MU::DEBUG, details: caller + ["Competing call stack"] + @groom_locks[method]
+          end
+          @groom_locks[method] = caller
+        }
+        if method != :saveSecret
+          MU.log "Calling groomer method #{method}", MU::DEBUG, details: args
+        else
+          MU.log "Calling groomer method #{method}", MU::DEBUG, details: ["sensitive output suppress"]
+        end
+        begin
+          if !args.nil? and args.size == 1
+            retval = @groomer_obj.method(method).call(args.first)
+          elsif !args.nil? and args.size > 0
+            retval = @groomer_obj.method(method).call(*args)
+          else
+            retval = @groomer_obj.method(method).call
+          end
+        rescue Exception => e
+        pp e.backtrace
+          raise MU::Groomer::RunError, e.message, e.backtrace
+        end
+        @groom_semaphore.synchronize {
+          @groom_locks.delete(method)
+        }
+        retval
+      end
+    }
+  end
+end

data/modules/mu/groomers/README.md

@@ -0,0 +1,58 @@
+Groomers
+--------
+
+This is where we implement support for host configuration providers like Chef
+or Puppet.  If you are writing a new Groomer plugin, we suggest you use the
+existing Chef Groomer implementation and this README as a guide.
+
+A `MU::Groomer` object is the generic interface to host configuration
+platforms, used so that other parts of Mu can operate on nodes without needing
+to know specifics about Chef or its ilk. 
+
+`MU::Groomer` objects are created for and invoked from `MU::Cloud::Server`
+objects during certain phases of their creation and upkeep. They run
+recipes/manifests/scripts to manage the host's configuration and share metadata
+from the rest of a Mu deployment.
+
+Any Groomer plugin must implement the following instance methods:
+
+**preClean**: Invoked to remove unsanctioned installs of host management
+software, which might be inherited from a machine image which came with Chef or
+its like pre-installed.
+
+**bootstrap**: Install our Groomer software on the Server to be managed and
+initialize it, e.g. by creating the node as a client on a Puppet or Chef
+master, setting up keys, etc.
+
+**haveBootstrapped?**: Should return true if bootstrap has already been
+successfully run on this node.
+
+**run**: Invoke our configuration management agent, e.g. *chef-client* or
+*puppet agent*.
+
+**saveDeployData**: Propagate Mu deployment metadata into the host management
+system so that it will be accessible from recipes/manifests.
+
+**getSecret**/**saveSecret**: Set or retrieve a piece of secured (encrypted,
+access-controlled) data from whatever mechanism this host management system
+uses for that job, e.g. Chef's Vault add-on.
+
+Additionally, you should implement class methods for the following:
+
+**getSecret**: Same as above, but without an object context. There is the
+occasional need.
+
+**cleanup**: Destroy all traces of saved Groomer data for a given node. This is
+a class method becauase cleanup operations are often performed on incomplete
+resources which may or may not have an available instance object.
+
+A Groomer object's constructor (the *initialize* method) will be passed a
+`MU::Cloud::Server` object on which to operate. These objects have a number of
+useful public instance methods, but the ones which will matter most when
+implementing a new Groomer are:
+
+**mu_name**: The "official" name of this node within Mu. This name is guaranteed to be unique amongst all `MU::Cloud::Server` objects managed by your Mu Master. If the host management platform you're implementing needs to name nodes something, it should be this.
+
+**getSSHSession**: This method will return a `Net::SSH::Session` object connected to the host which is being groomed.
+
+