microwave 0.1006.33 → 1.0.0

data/lib/chef/mixin/command/unix.rb

@@ -1,215 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# 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.
-#
-
-class Chef
-  module Mixin
-    module Command
-      module Unix
-        # This is taken directly from Ara T Howard's Open4 library, and then
-        # modified to suit the needs of Chef.  Any bugs here are most likely
-        # my own, and not Ara's.
-        #
-        # The original appears in external/open4.rb in its unmodified form.
-        #
-        # Thanks Ara!
-        def popen4(cmd, args={}, &b)
-
-          # Waitlast - this is magic.
-          #
-          # Do we wait for the child process to die before we yield
-          # to the block, or after?  That is the magic of waitlast.
-          #
-          # By default, we are waiting before we yield the block.
-          args[:waitlast] ||= false
-
-          args[:user] ||= nil
-          unless args[:user].kind_of?(Integer)
-            args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
-          end
-          args[:group] ||= nil
-          unless args[:group].kind_of?(Integer)
-            args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
-          end
-          args[:environment] ||= {}
-
-          # Default on C locale so parsing commands output can be done
-          # independently of the node's default locale.
-          # "LC_ALL" could be set to nil, in which case we also must ignore it.
-          unless args[:environment].has_key?("LC_ALL")
-            args[:environment]["LC_ALL"] = "C"
-          end
-
-          pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
-
-          verbose = $VERBOSE
-          begin
-            $VERBOSE = nil
-            ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-            cid = fork {
-              pw.last.close
-              STDIN.reopen pw.first
-              pw.first.close
-
-              pr.first.close
-              STDOUT.reopen pr.last
-              pr.last.close
-
-              pe.first.close
-              STDERR.reopen pe.last
-              pe.last.close
-
-              STDOUT.sync = STDERR.sync = true
-
-              if args[:group]
-                Process.egid = args[:group]
-                Process.gid = args[:group]
-              end
-
-              if args[:user]
-                Process.euid = args[:user]
-                Process.uid = args[:user]
-              end
-
-              args[:environment].each do |key,value|
-                ENV[key] = value
-              end
-
-              if args[:umask]
-                umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
-                File.umask(umask)
-              end
-
-              begin
-                if cmd.kind_of?(Array)
-                  exec(*cmd)
-                else
-                  exec(cmd)
-                end
-                raise 'forty-two'
-              rescue Exception => e
-                Marshal.dump(e, ps.last)
-                ps.last.flush
-              end
-              ps.last.close unless (ps.last.closed?)
-              exit!
-            }
-          ensure
-            $VERBOSE = verbose
-          end
-
-          [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
-
-          begin
-            e = Marshal.load ps.first
-            raise(Exception === e ? e : "unknown failure!")
-          rescue EOFError # If we get an EOF error, then the exec was successful
-            42
-          ensure
-            ps.first.close
-          end
-
-          pw.last.sync = true
-
-          pi = [pw.last, pr.first, pe.first]
-
-          if b
-            begin
-              if args[:waitlast]
-                b[cid, *pi]
-                # send EOF so that if the child process is reading from STDIN
-                # it will actually finish up and exit
-                pi[0].close_write
-                Process.waitpid2(cid).last
-              else
-                # This took some doing.
-                # The trick here is to close STDIN
-                # Then set our end of the childs pipes to be O_NONBLOCK
-                # Then wait for the child to die, which means any IO it
-                # wants to do must be done - it's dead.  If it isn't,
-                # it's because something totally skanky is happening,
-                # and we don't care.
-                o = StringIO.new
-                e = StringIO.new
-
-                pi[0].close
-
-                stdout = pi[1]
-                stderr = pi[2]
-
-                stdout.sync = true
-                stderr.sync = true
-
-                stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-                stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-
-                stdout_finished = false
-                stderr_finished = false
-
-                results = nil
-
-                while !stdout_finished || !stderr_finished
-                  begin
-                    channels_to_watch = []
-                    channels_to_watch << stdout if !stdout_finished
-                    channels_to_watch << stderr if !stderr_finished
-                    ready = IO.select(channels_to_watch, nil, nil, 1.0)
-                  rescue Errno::EAGAIN
-                  ensure
-                    results = Process.waitpid2(cid, Process::WNOHANG)
-                    if results
-                      stdout_finished = true
-                      stderr_finished = true
-                    end
-                  end
-
-                  if ready && ready.first.include?(stdout)
-                    line = results ? stdout.gets(nil) : stdout.gets
-                    if line
-                      o.write(line)
-                    else
-                      stdout_finished = true
-                    end
-                  end
-                  if ready && ready.first.include?(stderr)
-                    line = results ? stderr.gets(nil) : stderr.gets
-                    if line
-                      e.write(line)
-                    else
-                      stderr_finished = true
-                    end
-                  end
-                end
-                results = Process.waitpid2(cid) unless results
-                o.rewind
-                e.rewind
-                b[cid, pi[0], o, e]
-                results.last
-              end
-            ensure
-              pi.each{|fd| fd.close unless fd.closed?}
-            end
-          else
-            [cid, pw.last, pr.first, pe.first]
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/mixin/command/windows.rb

@@ -1,76 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# Author:: Doug MacEachern (<dougm@vmware.com>)
-# Copyright:: Copyright (c) 2010 VMware, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# 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.
-#
-
-if RUBY_VERSION =~ /^1\.8/
-  require 'win32/open3'
-else
-  require 'open3'
-end
-
-class Chef
-  module Mixin
-    module Command
-      module Windows
-        def popen4(cmd, args={}, &b)
-
-          # By default, we are waiting before we yield the block.
-          args[:waitlast] ||= false
-
-          #XXX :user, :group, :environment support?
-
-          Open3.popen3(cmd) do |stdin,stdout,stderr,cid|
-            if b
-              if args[:waitlast]
-                b[cid, stdin, stdout, stderr]
-                # send EOF so that if the child process is reading from STDIN
-                # it will actually finish up and exit
-                stdin.close_write
-              else
-                o = StringIO.new
-                e = StringIO.new
-
-                stdin.close
-
-                stdout.sync = true
-                stderr.sync = true
-
-                line = stdout.gets(nil)
-                if line
-                  o.write(line)
-                end
-                line = stderr.gets(nil)
-                if line
-                  e.write(line)
-                end
-                o.rewind
-                e.rewind
-                b[cid, stdin, o, e]
-              end
-            else
-              [cid, stdin, stdout, stderr]
-            end
-          end
-          $?
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/mixin/convert_to_class_name.rb

@@ -1,63 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2009 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# 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.
-#
-
-class Chef
-  module Mixin
-    module ConvertToClassName
-      extend self
-
-      def convert_to_class_name(str)
-        rname = nil
-        regexp = %r{^(.+?)(_(.+))?$}
-        
-        mn = str.match(regexp)
-        if mn
-          rname = mn[1].capitalize
-
-          while mn && mn[3]
-            mn = mn[3].match(regexp)          
-            rname << mn[1].capitalize if mn
-          end
-        end
-
-        rname
-      end
-      
-      def convert_to_snake_case(str, namespace=nil)
-        str = str.dup
-        str.sub!(/^#{namespace}(\:\:)?/, '') if namespace
-        str.gsub!(/[A-Z]/) {|s| "_" + s}
-        str.downcase!
-        str.sub!(/^\_/, "")
-        str
-      end
-      
-      def snake_case_basename(str)
-        with_namespace = convert_to_snake_case(str)
-        with_namespace.split("::").last.sub(/^_/, '')
-      end
-      
-      def filename_to_qualified_string(base, filename)
-        file_base = File.basename(filename, ".rb")
-        base.to_s + (file_base == 'default' ? '' : "_#{file_base}")
-      end
-      
-    end
-  end
-end

data/lib/chef/mixin/create_path.rb

@@ -1,57 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# 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.
-
-class Chef
-  module Mixin
-    module CreatePath
-      
-      # Creates a given path, including all directories that lead up to it.
-      # Like mkdir_p, but without the leaking.
-      #
-      # === Parameters
-      # file_path<String, Array>:: A string that represents the path to create, 
-      #   or an Array with the path-parts.
-      #
-      # === Returns
-      # The created file_path.
-      def create_path(file_path)
-        unless file_path.kind_of?(String) || file_path.kind_of?(Array)
-          raise ArgumentError, "file_path must be a string or an array!" 
-        end
-        
-        if file_path.kind_of?(String)
-          file_path = File.expand_path(file_path).split(File::SEPARATOR)
-          file_path.shift if file_path[0] == ''
-          # Check if path starts with a separator or drive letter (Windows)
-          unless file_path[0].match("^#{File::SEPARATOR}|^[a-zA-Z]:")
-            file_path[0] = "#{File::SEPARATOR}#{file_path[0]}"
-          end
-        end
-                
-        file_path.each_index do |i|
-          create_path = File.join(file_path[0, i + 1])
-          unless File.directory?(create_path)
-            Chef::Log.debug("Creating directory #{create_path}")
-            Dir.mkdir(create_path)
-          end 
-        end
-        File.expand_path(File.join(file_path))
-      end
-  
-    end
-  end
-end

data/lib/chef/mixin/deep_merge.rb

@@ -1,225 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Steve Midgley (http://www.misuse.org/science)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
-# Copyright:: Copyright (c) 2008 Steve Midgley
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# 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.
-
-class Chef
-  module Mixin
-    # == Chef::Mixin::DeepMerge
-    # Implements a deep merging algorithm for nested data structures.
-    # ==== Notice:
-    #   This code is imported from deep_merge by Steve Midgley. deep_merge is
-    #   available under the MIT license from
-    #   http://trac.misuse.org/science/wiki/DeepMerge
-    module DeepMerge
-      def self.merge(first, second)
-        first  = Mash.new(first)  unless first.kind_of?(Mash)
-        second = Mash.new(second) unless second.kind_of?(Mash)
-
-        DeepMerge.deep_merge!(second, first, {:knockout_prefix => "!merge:", :preserve_unmergeables => false})
-      end
-    
-      class InvalidParameter < StandardError; end
-      
-      DEFAULT_FIELD_KNOCKOUT_PREFIX = '--' unless defined?(DEFAULT_FIELD_KNOCKOUT_PREFIX)
-     
-      # Deep Merge core documentation.
-      # deep_merge! method permits merging of arbitrary child elements. The two top level
-      # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
-      # of child elements. These child elements to not have to be of the same types.
-      # Where child elements are of the same type, deep_merge will attempt to merge them together.
-      # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
-      # the destination element with the contents of the source element at that level.
-      # So if you have two hashes like this:
-      #   source = {:x => [1,2,3], :y => 2}
-      #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
-      #   dest.deep_merge!(source)
-      #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
-      # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
-      # To avoid this, use "deep_merge" (no bang/exclamation mark)
-      # 
-      # Options:
-      #   Options are specified in the last parameter passed, which should be in hash format:
-      #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
-      #   :preserve_unmergeables  DEFAULT: false
-      #      Set to true to skip any unmergeable elements from source
-      #   :knockout_prefix        DEFAULT: nil
-      #      Set to string value to signify prefix which deletes elements from existing element
-      #   :sort_merged_arrays     DEFAULT: false
-      #      Set to true to sort all arrays that are merged together
-      #   :unpack_arrays          DEFAULT: nil
-      #      Set to string value to run "Array::join" then "String::split" against all arrays
-      #   :merge_debug            DEFAULT: false
-      #      Set to true to get console output of merge process for debugging
-      #
-      # Selected Options Details:
-      # :knockout_prefix => The purpose of this is to provide a way to remove elements 
-      #   from existing Hash by specifying them in a special way in incoming hash
-      #    source = {:x => ['--1', '2']}
-      #    dest   = {:x => ['1', '3']}
-      #    dest.ko_deep_merge!(source)
-      #    Results: {:x => ['2','3']}
-      #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
-      #   the entire element to be removed:
-      #    source = {:x => '--'}
-      #    dest   = {:x => [1,2,3]}
-      #    dest.ko_deep_merge!(source)
-      #    Results: {:x => ""}
-      # :unpack_arrays => The purpose of this is to permit compound elements to be passed
-      #   in as strings and to be converted into discrete array elements
-      #   irsource = {:x => ['1,2,3', '4']}
-      #   dest   = {:x => ['5','6','7,8']}
-      #   dest.deep_merge!(source, {:unpack_arrays => ','})
-      #   Results: {:x => ['1','2','3','4','5','6','7','8'}
-      #   Why: If receiving data from an HTML form, this makes it easy for a checkbox 
-      #    to pass multiple values from within a single HTML element
-      # 
-      # There are many tests for this library - and you can learn more about the features
-      # and usages of deep_merge! by just browsing the test examples
-      def self.deep_merge!(source, dest, options = {})
-        # turn on this line for stdout debugging text
-        merge_debug = options[:merge_debug] || false
-        overwrite_unmergeable = !options[:preserve_unmergeables]
-        knockout_prefix = options[:knockout_prefix] || nil
-        raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
-        raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
-        # if present: we will split and join arrays on this char before merging
-        array_split_char = options[:unpack_arrays] || false
-        # request that we sort together any arrays when they are merged
-        sort_merged_arrays = options[:sort_merged_arrays] || false
-        di = options[:debug_indent] || ''
-        # do nothing if source is nil
-        return dest if source.nil?
-        # if dest doesn't exist, then simply copy source to it
-        if dest.nil? && overwrite_unmergeable
-          dest = source; return dest
-        end
-     
-        puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
-        if source.kind_of?(Hash)
-          puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
-          source.each do |src_key, src_value|
-            if dest.kind_of?(Hash)
-              puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
-              if dest[src_key]
-                puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
-                dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
-              else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
-                puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
-                # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
-                begin
-                  src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
-                rescue TypeError
-                  src_dup = src_value
-                end
-                dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
-              end
-            else # dest isn't a hash, so we overwrite it completely (if permitted)
-              if overwrite_unmergeable
-                puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
-                dest = overwrite_unmergeables(source, dest, options)
-              end
-            end
-          end
-        elsif source.kind_of?(Array)
-          puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
-          # if we are instructed, join/split any source arrays before processing
-          if array_split_char
-            puts "#{di} split/join on source: #{source.inspect}" if merge_debug
-            source = source.join(array_split_char).split(array_split_char)
-            if dest.kind_of?(Array)
-              dest = dest.join(array_split_char).split(array_split_char)
-            end
-          end
-          # if there's a naked knockout_prefix in source, that means we are to truncate dest
-          if source.index(knockout_prefix)
-            dest = clear_or_nil(dest); source.delete(knockout_prefix)
-          end
-          if dest.kind_of?(Array)
-            if knockout_prefix
-              print "#{di} knocking out: " if merge_debug
-              # remove knockout prefix items from both source and dest
-              source.delete_if do |ko_item|
-                retval = false
-                item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
-                if item != ko_item
-                  print "#{ko_item} - " if merge_debug
-                  dest.delete(item)
-                  dest.delete(ko_item)
-                  retval = true
-                end
-                retval
-              end
-              puts if merge_debug
-            end
-            puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
-            dest = dest | source
-            dest.sort! if sort_merged_arrays
-          elsif overwrite_unmergeable
-            puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
-            dest = overwrite_unmergeables(source, dest, options)
-          end
-        else # src_hash is not an array or hash, so we'll have to overwrite dest
-          puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
-          dest = overwrite_unmergeables(source, dest, options)
-        end
-        puts "#{di}Returning #{dest.inspect}" if merge_debug
-        dest
-      end # deep_merge!
-     
-      # allows deep_merge! to uniformly handle overwriting of unmergeable entities
-      def self.overwrite_unmergeables(source, dest, options)
-        merge_debug = options[:merge_debug] || false
-        overwrite_unmergeable = !options[:preserve_unmergeables]
-        knockout_prefix = options[:knockout_prefix] || false
-        di = options[:debug_indent] || ''
-        if knockout_prefix && overwrite_unmergeable
-          if source.kind_of?(String) # remove knockout string from source before overwriting dest
-            src_tmp = source.gsub(%r{^#{knockout_prefix}},"")
-          elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
-            src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
-          else
-            src_tmp = source
-          end
-          if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
-            puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
-            dest = src_tmp
-          else # if we do find a knockout_prefix, then we just delete dest
-            puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
-            dest = ""
-          end
-        elsif overwrite_unmergeable
-          dest = source
-        end
-        dest
-      end
-     
-      def self.clear_or_nil(obj)
-        if obj.respond_to?(:clear)
-          obj.clear
-        else
-          obj = nil
-        end
-        obj
-      end
-     
-    end
-     
-  end
-end
-
-