clc-fork-chef-metal 0.11.beta.5

data/lib/chef_metal/machine.rb

@@ -0,0 +1,110 @@
+module ChefMetal
+  class Machine
+    def initialize(machine_spec)
+      @machine_spec = machine_spec
+    end
+
+    attr_reader :machine_spec
+
+    def name
+      machine_spec.name
+    end
+
+    def node
+      machine_spec.node
+    end
+
+    # Sets up everything necessary for convergence to happen on the machine.
+    # The node MUST be saved as part of this procedure.  Other than that,
+    # nothing is guaranteed except that converge() will work when this is done.
+    def setup_convergence(action_handler)
+      raise "setup_convergence not overridden on #{self.class}"
+    end
+
+    def converge(action_handler)
+      raise "converge not overridden on #{self.class}"
+    end
+
+    def cleanup_convergence(action_handler)
+      raise "cleanup_convergence not overridden on #{self.class}"
+    end
+
+    def execute(action_handler, command, options = {})
+      raise "execute not overridden on #{self.class}"
+    end
+
+    def execute_always(command, options = {})
+      raise "execute_always not overridden on #{self.class}"
+    end
+
+    def read_file(path)
+      raise "read_file not overridden on #{self.class}"
+    end
+
+    def download_file(action_handler, path, local_path)
+      raise "read_file not overridden on #{self.class}"
+    end
+
+    def write_file(action_handler, path, content)
+      raise "write_file not overridden on #{self.class}"
+    end
+
+    def upload_file(action_handler, local_path, path)
+      raise "write_file not overridden on #{self.class}"
+    end
+
+    def create_dir(action_handler, path)
+      raise "create_dir not overridden on #{self.class}"
+    end
+
+    # Delete file
+    def delete_file(action_handler, path)
+      raise "delete_file not overridden on #{self.class}"
+    end
+
+    # Return true if directory, false/nil if not
+    def is_directory?(path)
+      raise "is_directory? not overridden on #{self.class}"
+    end
+
+    # Return true or false depending on whether file exists
+    def file_exists?(path)
+      raise "file_exists? not overridden on #{self.class}"
+    end
+
+    # Return true or false depending on whether remote file differs from local path or content
+    def files_different?(path, local_path, content=nil)
+      raise "file_different? not overridden on #{self.class}"
+    end
+
+    # Set file attributes { mode, :owner, :group }
+    def set_attributes(action_handler, path, attributes)
+      raise "set_attributes not overridden on #{self.class}"
+    end
+
+    # Get file attributes { :mode, :owner, :group }
+    def get_attributes(path)
+      raise "get_attributes not overridden on #{self.class}"
+    end
+
+    # Ensure the given URL can be reached by the remote side (possibly by port forwarding)
+    # Must return the URL that the remote side can use to reach the local_url
+    def make_url_available_to_remote(local_url)
+      raise "make_url_available_to_remote not overridden on #{self.class}"
+    end
+
+    def disconnect
+      raise "disconnect not overridden on #{self.class}"
+    end
+
+    # TODO get rid of the action_handler attribute, that is ridiculous
+    # Detect the OS on the machine (assumes the machine is up)
+    # Returns a triplet:
+    #   platform, platform_version, machine_architecture = machine.detect_os(action_handler)
+    # This triplet is suitable for passing to the Chef metadata API:
+    # https://www.opscode.com/chef/metadata?p=#{platform}&pv=#{platform_version}&m=#{machine_architecture}
+    def detect_os(action_handler)
+      raise "detect_os not overridden on #{self.class}"
+    end
+  end
+end

data/lib/chef_metal/machine/basic_machine.rb

@@ -0,0 +1,82 @@
+require 'chef_metal/machine'
+
+module ChefMetal
+  class Machine
+    class BasicMachine < Machine
+      def initialize(machine_spec, transport, convergence_strategy)
+        super(machine_spec)
+        @transport = transport
+        @convergence_strategy = convergence_strategy
+      end
+
+      attr_reader :transport
+      attr_reader :convergence_strategy
+
+      def setup_convergence(action_handler)
+        convergence_strategy.setup_convergence(action_handler, self)
+      end
+
+      def converge(action_handler)
+        convergence_strategy.converge(action_handler, self)
+      end
+
+      def cleanup_convergence(action_handler)
+        convergence_strategy.cleanup_convergence(action_handler, machine_spec)
+      end
+
+      def execute(action_handler, command, options = {})
+        action_handler.perform_action "run '#{command}' on #{machine_spec.name}" do
+          result = transport.execute(command, options)
+          result.error!
+          result
+        end
+      end
+
+      def execute_always(command, options = {})
+        transport.execute(command, options)
+      end
+
+      def read_file(path)
+        transport.read_file(path)
+      end
+
+      def download_file(action_handler, path, local_path)
+        if files_different?(path, local_path)
+          action_handler.perform_action "download file #{path} on #{machine_spec.name} to #{local_path}" do
+            transport.download_file(path, local_path)
+          end
+        end
+      end
+
+      def write_file(action_handler, path, content, options = {})
+        if files_different?(path, nil, content)
+          if options[:ensure_dir]
+            create_dir(action_handler, dirname_on_machine(path))
+          end
+          action_handler.perform_action "write file #{path} on #{machine_spec.name}" do
+            transport.write_file(path, content)
+          end
+        end
+      end
+
+      def upload_file(action_handler, local_path, path, options = {})
+        if files_different?(path, local_path)
+          if options[:ensure_dir]
+            create_dir(action_handler, dirname_on_machine(path))
+          end
+          action_handler.perform_action "upload file #{local_path} to #{path} on #{machine_spec.name}" do
+            transport.upload_file(local_path, path)
+          end
+        end
+      end
+
+      def make_url_available_to_remote(local_url)
+        transport.make_url_available_to_remote(local_url)
+      end
+
+      def disconnect
+        transport.disconnect
+      end
+    end
+  end
+end

data/lib/chef_metal/machine/unix_machine.rb

@@ -0,0 +1,276 @@
+require 'chef_metal/machine/basic_machine'
+require 'digest'
+
+module ChefMetal
+  class Machine
+    class UnixMachine < BasicMachine
+      def initialize(machine_spec, transport, convergence_strategy)
+        super
+
+        @tmp_dir = '/tmp'
+      end
+
+      # Options include:
+      #
+      # command_prefix - prefix to put in front of any command, e.g. sudo
+      attr_reader :options
+
+      # Delete file
+      def delete_file(action_handler, path)
+        if file_exists?(path)
+          action_handler.perform_action "delete file #{path} on #{machine_spec.name}" do
+            transport.execute("rm -f #{path}").error!
+          end
+        end
+      end
+
+      def is_directory?(path)
+        result = transport.execute("stat -c '%F' #{path}", :read_only => true)
+        return nil if result.exitstatus != 0
+        result.stdout.chomp == 'directory'
+      end
+
+      # Return true or false depending on whether file exists
+      def file_exists?(path)
+        result = transport.execute("ls -d #{path}", :read_only => true)
+        result.exitstatus == 0 && result.stdout != ''
+      end
+
+      def files_different?(path, local_path, content=nil)
+        if !file_exists?(path) || (local_path && !File.exists?(local_path))
+          return true
+        end
+
+        # Get remote checksum of file
+        result = transport.execute("md5sum -b #{path}", :read_only => true)
+        result.error!
+        remote_sum = result.stdout.split(' ')[0]
+
+        digest = Digest::MD5.new
+        if content
+          digest.update(content)
+        else
+          File.open(local_path, 'rb') do |io|
+            while (buf = io.read(4096)) && buf.length > 0
+              digest.update(buf)
+            end
+          end
+        end
+        remote_sum != digest.hexdigest
+      end
+
+      def create_dir(action_handler, path)
+        if !file_exists?(path)
+          action_handler.perform_action "create directory #{path} on #{machine_spec.name}" do
+            transport.execute("mkdir -p #{path}").error!
+          end
+        end
+      end
+
+      # Set file attributes { mode, :owner, :group }
+      def set_attributes(action_handler, path, attributes)
+        if attributes[:mode] || attributes[:owner] || attributes[:group]
+          current_attributes = get_attributes(path)
+          if attributes[:mode] && current_attributes[:mode].to_i != attributes[:mode].to_i
+            action_handler.perform_action "change mode of #{path} on #{machine_spec.name} from #{current_attributes[:mode].to_i} to #{attributes[:mode].to_i}" do
+              transport.execute("chmod #{attributes[:mode].to_i} #{path}").error!
+            end
+          end
+          if attributes[:owner] && current_attributes[:owner] != attributes[:owner]
+            action_handler.perform_action "change group of #{path} on #{machine_spec.name} from #{current_attributes[:owner]} to #{attributes[:owner]}" do
+              transport.execute("chown #{attributes[:owner]} #{path}").error!
+            end
+          end
+          if attributes[:group] && current_attributes[:group] != attributes[:group]
+            action_handler.perform_action "change group of #{path} on #{machine_spec.name} from #{current_attributes[:group]} to #{attributes[:group]}" do
+              transport.execute("chgrp #{attributes[:group]} #{path}").error!
+            end
+          end
+        end
+      end
+
+      # Get file attributes { :mode, :owner, :group }
+      def get_attributes(path)
+        result = transport.execute("stat -c '%a %U %G %n' #{path}", :read_only => true)
+        return nil if result.exitstatus != 0
+        file_info = result.stdout.split(/\s+/)
+        if file_info.size <= 1
+          raise "#{path} does not exist in set_attributes()"
+        end
+        result = {
+          :mode => file_info[0],
+          :owner => file_info[1],
+          :group => file_info[2]
+        }
+      end
+
+      def dirname_on_machine(path)
+        path.split('/')[0..-2].join('/')
+      end
+    end
+
+    def detect_os(action_handler)
+      #
+      # Use detect.sh to detect the operating system of the remote machine
+      #
+      # TODO do this in terms of commands rather than writing a shell script
+      self.write_file(action_handler, "#{@tmp_dir}/detect.sh", detect_sh)
+      detected = self.execute_always("sh #{@tmp_dir}/detect.sh")
+      if detected.exitstatus != 0
+        raise "detect.sh exited with nonzero exit status: #{detected.exitstatus}"
+      end
+      platform = nil
+      platform_version = nil
+      machine_architecture = nil
+      detected.stdout.each_line do |line|
+        if line =~ /^PLATFORM: (.+)/
+          platform = $1
+        elsif line =~ /^PLATFORM_VERSION: (.+)/
+          platform_version = $1
+        elsif line =~ /^MACHINE: (.+)/
+          machine_architecture = $1
+        end
+      end
+      [ platform, platform_version, machine_architecture ]
+    end
+
+    private
+
+    def detect_sh
+      result = <<EOM
+prerelease="false"
+
+project="chef"
+
+report_bug() {
+echo "Please file a bug report at http://tickets.opscode.com"
+echo "Project: Chef"
+echo "Component: Packages"
+echo "Label: Omnibus"
+echo "Version: $version"
+echo " "
+echo "Please detail your operating system type, version and any other relevant details"
+}
+
+
+machine=`uname -m`
+os=`uname -s`
+
+# Retrieve Platform and Platform Version
+if test -f "/etc/lsb-release" && grep -q DISTRIB_ID /etc/lsb-release; then
+platform=`grep DISTRIB_ID /etc/lsb-release | cut -d "=" -f 2 | tr '[A-Z]' '[a-z]'`
+platform_version=`grep DISTRIB_RELEASE /etc/lsb-release | cut -d "=" -f 2`
+elif test -f "/etc/debian_version"; then
+platform="debian"
+platform_version=`cat /etc/debian_version`
+elif test -f "/etc/redhat-release"; then
+platform=`sed 's/^\\(.\\+\\) release.*/\\1/' /etc/redhat-release | tr '[A-Z]' '[a-z]'`
+platform_version=`sed 's/^.\\+ release \\([.0-9]\\+\\).*/\\1/' /etc/redhat-release`
+
+# If /etc/redhat-release exists, we act like RHEL by default
+if test "$platform" = "fedora"; then
+# Change platform version for use below.
+platform_version="6.0"
+fi
+platform="el"
+elif test -f "/etc/system-release"; then
+platform=`sed 's/^\\(.\\+\\) release.\\+/\\1/' /etc/system-release | tr '[A-Z]' '[a-z]'`
+platform_version=`sed 's/^.\\+ release \\([.0-9]\\+\\).*/\\1/' /etc/system-release | tr '[A-Z]' '[a-z]'`
+# amazon is built off of fedora, so act like RHEL
+if test "$platform" = "amazon linux ami"; then
+platform="el"
+platform_version="6.0"
+fi
+# Apple OS X
+elif test -f "/usr/bin/sw_vers"; then
+platform="mac_os_x"
+# Matching the tab-space with sed is error-prone
+platform_version=`sw_vers | awk '/^ProductVersion:/ { print $2 }'`
+
+major_version=`echo $platform_version | cut -d. -f1,2`
+case $major_version in
+"10.6") platform_version="10.6" ;;
+"10.7"|"10.8"|"10.9") platform_version="10.7" ;;
+*) echo "No builds for platform: $major_version"
+ report_bug
+ exit 1
+ ;;
+esac
+
+# x86_64 Apple hardware often runs 32-bit kernels (see OHAI-63)
+x86_64=`sysctl -n hw.optional.x86_64`
+if test $x86_64 -eq 1; then
+machine="x86_64"
+fi
+elif test -f "/etc/release"; then
+platform="solaris2"
+machine=`/usr/bin/uname -p`
+platform_version=`/usr/bin/uname -r`
+elif test -f "/etc/SuSE-release"; then
+if grep -q 'Enterprise' /etc/SuSE-release;
+then
+platform="sles"
+platform_version=`awk '/^VERSION/ {V = $3}; /^PATCHLEVEL/ {P = $3}; END {print V "." P}' /etc/SuSE-release`
+else
+platform="suse"
+platform_version=`awk '/^VERSION =/ { print $3 }' /etc/SuSE-release`
+fi
+elif test "x$os" = "xFreeBSD"; then
+platform="freebsd"
+platform_version=`uname -r | sed 's/-.*//'`
+elif test "x$os" = "xAIX"; then
+platform="aix"
+platform_version=`uname -v`
+machine="ppc"
+fi
+
+if test "x$platform" = "x"; then
+echo "Unable to determine platform version!"
+report_bug
+exit 1
+fi
+
+# Mangle $platform_version to pull the correct build
+# for various platforms
+major_version=`echo $platform_version | cut -d. -f1`
+case $platform in
+"el")
+platform_version=$major_version
+;;
+"debian")
+case $major_version in
+"5") platform_version="6";;
+"6") platform_version="6";;
+"7") platform_version="6";;
+esac
+;;
+"freebsd")
+platform_version=$major_version
+;;
+"sles")
+platform_version=$major_version
+;;
+"suse")
+platform_version=$major_version
+;;
+esac
+
+if test "x$platform_version" = "x"; then
+echo "Unable to determine platform version!"
+report_bug
+exit 1
+fi
+
+if test "x$platform" = "xsolaris2"; then
+# hack up the path on Solaris to find wget
+PATH=/usr/sfw/bin:$PATH
+export PATH
+fi
+
+echo "PLATFORM: $platform"
+echo "PLATFORM_VERSION: $platform_version"
+echo "MACHINE: $machine"
+EOM
+    end
+  end
+end