vagrant-openstack 0.0.4

data/tmp/librarian/cache/source/chef/site/877777683730772c36b1e6a3fc3aa2c3/windows/version-uri/d397cdaf12ebdc0fa57a2847df7926e2/package/attributes/default.rb

@@ -0,0 +1,22 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Cookbook Name:: windows
+# Attribute:: default
+#
+# Copyright 2011, Opscode, Inc
+#
+# 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.
+#
+
+default['windows']['allow_pending_reboots'] = true
+default['windows']['rubyzipversion'] = nil

data/tmp/librarian/cache/source/chef/site/877777683730772c36b1e6a3fc3aa2c3/windows/version-uri/d397cdaf12ebdc0fa57a2847df7926e2/package/files/default/handlers/windows_reboot_handler.rb

@@ -0,0 +1,76 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 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 WindowsRebootHandler < Chef::Handler
+  include Chef::Mixin::ShellOut
+
+  def initialize(allow_pending_reboots = true, timeout = 60, reason = "Opscode Chef initiated reboot")
+    @allow_pending_reboots = allow_pending_reboots
+    @timeout = timeout
+    @reason = reason
+  end
+
+  def report
+    log_message, reboot = begin
+      if reboot_requested?
+        ["chef_handler[#{self.class}] requested reboot will occur in #{timeout} seconds", true]
+      elsif reboot_pending?
+        if @allow_pending_reboots
+          ["chef_handler[#{self.class}] reboot pending - automatic reboot will occur in #{timeout} seconds", true]
+        else
+          ["chef_handler[#{self.class}] reboot pending but handler not configured to act on pending reboots - please reboot node manually", false]
+        end
+      else
+        ["chef_handler[#{self.class}] no reboot requested or pending", false]
+      end
+    end
+
+    Chef::Log.warn(log_message)
+    shell_out!("shutdown /r /t #{timeout} /c \"#{reason}\"") if reboot
+  end
+
+  private
+  # reboot cause CHEF says so:
+  # reboot explicitly requested in our cookbook code
+  def reboot_requested?
+    node.run_state[:reboot_requested] == true
+  end
+
+  # reboot cause WIN says so:
+  # reboot pending because of some configuration action we performed
+  def reboot_pending?
+    # Any files listed here means reboot needed
+    (Registry.key_exists?('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations') &&
+      Registry.get_value('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager','PendingFileRenameOperations').any?) ||
+    # 1 for any value means reboot pending
+    # "9306cdfc-c4a1-4a22-9996-848cb67eddc3"=1
+    (Registry.key_exists?('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired') &&
+      Registry.get_values('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired').select{|v| v[2] == 1 }.any?) ||
+    # 1 or 2 for 'Flags' value means reboot pending
+    (Registry.key_exists?('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile') &&
+      [1,2].include?(Registry::get_value('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile','Flags')))
+  end
+
+  def timeout
+    node.run_state[:reboot_timeout] || @timeout
+  end
+
+  def reason
+    node.run_state[:reboot_reason] || @reason
+  end
+end

data/tmp/librarian/cache/source/chef/site/877777683730772c36b1e6a3fc3aa2c3/windows/version-uri/d397cdaf12ebdc0fa57a2847df7926e2/package/libraries/feature_base.rb

@@ -0,0 +1,41 @@
+class Chef
+  class Provider
+    class WindowsFeature
+      module Base
+
+        def action_install
+          unless installed?
+            install_feature(@new_resource.feature_name)
+            @new_resource.updated_by_last_action(true)
+            Chef::Log.info("#{@new_resource} installed feature")
+          else
+            Chef::Log.debug("#{@new_resource} is already installed - nothing to do")
+          end
+        end
+
+        def action_remove
+          if installed?
+            remove_feature(@new_resource.feature_name)
+            @new_resource.updated_by_last_action(true)
+            Chef::Log.info("#{@new_resource} removed")
+          else
+            Chef::Log.debug("#{@new_resource} feature does not exist - nothing to do")
+          end
+        end
+
+        def install_feature(name)
+          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :install"
+        end
+
+        def remove_feature(name)
+          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :remove"
+        end
+
+        def installed?
+          raise Chef::Exceptions::Override, "You must override installed? in #{self.to_s}"
+        end
+      end
+    end
+  end
+end
+      

data/tmp/librarian/cache/source/chef/site/877777683730772c36b1e6a3fc3aa2c3/windows/version-uri/d397cdaf12ebdc0fa57a2847df7926e2/package/libraries/helper.rb

@@ -0,0 +1,86 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Cookbook Name:: windows
+# Library:: helper
+#
+# Copyright:: 2011, Opscode, Inc.
+#
+# 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.
+#
+
+module Windows
+  module Helper
+
+    AUTO_RUN_KEY = 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run'
+    ENV_KEY = 'HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment'
+
+    # returns windows friendly version of the provided path, 
+    # ensures backslashes are used everywhere
+    def win_friendly_path(path)
+      path.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR) if path
+    end
+
+    # account for Window's wacky File System Redirector
+    # http://msdn.microsoft.com/en-us/library/aa384187(v=vs.85).aspx
+    # especially important for 32-bit processes (like Ruby) on a 
+    # 64-bit instance of Windows.
+    def locate_sysnative_cmd(cmd)
+      if ::File.exists?("#{ENV['WINDIR']}\\sysnative\\#{cmd}")
+        "#{ENV['WINDIR']}\\sysnative\\#{cmd}"
+      elsif ::File.exists?("#{ENV['WINDIR']}\\system32\\#{cmd}")
+        "#{ENV['WINDIR']}\\system32\\#{cmd}"
+      else
+        cmd
+      end
+    end
+
+    # Create a feature provider dependent value object.
+    # mainly created becasue Windows Feature names are 
+    # different based on whether dism.exe or servicemanagercmd.exe 
+    # is used for installation
+    def value_for_feature_provider(provider_hash)
+      p = Chef::Platform.find_provider_for_node(node, :windows_feature)
+      key = p.to_s.downcase.split('::').last
+      provider_hash[key] || provider_hash[key.to_sym]
+    end
+
+    # singleton instance of the Windows Version checker
+    def win_version
+      @win_version ||= Windows::Version.new
+    end
+
+    # if a file is local it returns a windows friendly path version
+    # if a file is remote it caches it locally
+    def cached_file(source, checksum=nil, windows_path=true)
+      @installer_file_path ||= begin
+
+        if(source =~ /^(https?:\/\/)(.*\/)(.*)$/)
+          cache_file_path = "#{Chef::Config[:file_cache_path]}/#{::File.basename(source)}"
+          Chef::Log.debug("Caching a copy of file #{source} at #{cache_file_path}")
+          r = Chef::Resource::RemoteFile.new(cache_file_path, run_context)
+          r.source(source)
+          r.backup(false)
+          r.checksum(checksum) if checksum
+          r.run_action(:create)
+        else
+          cache_file_path = source
+        end
+
+        windows_path ? win_friendly_path(cache_file_path) : cache_file_path
+      end
+    end
+
+  end
+end
+
+Chef::Recipe.send(:include, Windows::Helper)

data/tmp/librarian/cache/source/chef/site/877777683730772c36b1e6a3fc3aa2c3/windows/version-uri/d397cdaf12ebdc0fa57a2847df7926e2/package/libraries/registry_helper.rb

@@ -0,0 +1,357 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Author:: Paul Morton (<pmorton@biaprotect.com>)
+# Cookbook Name:: windows
+# Provider:: registry
+#
+# Copyright:: 2010, VMware, Inc.
+# Copyright:: 2011, Opscode, Inc.
+# Copyright:: 2011, Business Intelligence Associates, Inc
+#
+# 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_PLATFORM =~ /mswin|mingw32|windows/
+  require 'win32/registry'
+  require 'ruby-wmi'
+end
+
+module Windows
+  module RegistryHelper
+
+    @@native_registry_constant = ENV['PROCESSOR_ARCHITEW6432'] == 'AMD64' ? 0x0100 : 0x0200
+
+    def get_hive_name(path)
+      Chef::Log.debug("Resolving registry shortcuts to full names")
+
+      reg_path = path.split("\\")
+      hive_name = reg_path.shift
+
+      hkey = {
+        "HKLM" => "HKEY_LOCAL_MACHINE",
+        "HKCU" => "HKEY_CURRENT_USER",
+        "HKU"  => "HKEY_USERS"
+      }[hive_name] || hive_name
+
+      Chef::Log.debug("Hive resolved to #{hkey}")
+      return hkey
+    end
+
+    def get_hive(path)
+
+      Chef::Log.debug("Getting hive for #{path}")
+      reg_path = path.split("\\")
+      hive_name = reg_path.shift
+
+      hkey = get_hive_name(path)
+
+      hive = {
+        "HKEY_LOCAL_MACHINE" => ::Win32::Registry::HKEY_LOCAL_MACHINE,
+        "HKEY_USERS" => ::Win32::Registry::HKEY_USERS,
+        "HKEY_CURRENT_USER" => ::Win32::Registry::HKEY_CURRENT_USER
+        }[hkey]
+
+      unless hive
+        Chef::Application.fatal!("Unsupported registry hive '#{hive_name}'")
+      end
+
+
+      Chef::Log.debug("Registry hive resolved to #{hkey}")
+      return hive
+    end
+
+    def unload_hive(path)
+      hive = get_hive(path)
+      if hive == ::Win32::Registry::HKEY_USERS
+        reg_path = path.split("\\")
+        priv = Chef::WindowsPrivileged.new
+        begin
+          priv.reg_unload_key(reg_path[1])
+        rescue
+        end
+      end
+    end
+
+    def set_value(mode,path,values,type=nil)
+      hive, reg_path, hive_name, root_key, hive_loaded = get_reg_path_info(path)
+      key_name = reg_path.join("\\")
+
+      Chef::Log.debug("Creating #{path}")
+
+      if !key_exists?(path,true)
+        create_key(path)
+      end
+
+      hive.send(mode, key_name, ::Win32::Registry::KEY_ALL_ACCESS | @@native_registry_constant) do |reg|
+        changed_something = false
+        values.each do |k,val|
+          key = "#{k}" #wtf. avoid "can't modify frozen string" in win32/registry.rb
+          cur_val = nil
+          begin
+            cur_val = reg[key]
+          rescue
+            #subkey does not exist (ok)
+          end
+          if cur_val != val
+            Chef::Log.debug("setting #{key}=#{val}")
+            
+            if type.nil?
+              type = :string
+            end
+
+            reg_type = {
+              :binary => ::Win32::Registry::REG_BINARY,
+              :string => ::Win32::Registry::REG_SZ,
+              :multi_string => ::Win32::Registry::REG_MULTI_SZ,
+              :expand_string => ::Win32::Registry::REG_EXPAND_SZ,
+              :dword => ::Win32::Registry::REG_DWORD,
+              :dword_big_endian => ::Win32::Registry::REG_DWORD_BIG_ENDIAN,
+              :qword => ::Win32::Registry::REG_QWORD
+            }[type]
+
+            reg.write(key, reg_type, val)
+
+            ensure_hive_unloaded(hive_loaded)
+
+            changed_something = true
+          end
+        end
+        return changed_something
+      end
+      return false
+    end
+
+    def get_value(path,value)
+      hive, reg_path, hive_name, root_key, hive_loaded = get_reg_path_info(path)
+      key = reg_path.join("\\")
+
+      hive.open(key, ::Win32::Registry::KEY_ALL_ACCESS | @@native_registry_constant) do | reg |
+        begin
+          return reg[value]
+        rescue
+          return nil
+        ensure
+          ensure_hive_unloaded(hive_loaded)
+        end
+      end
+    end
+
+    def get_values(path)
+      hive, reg_path, hive_name, root_key, hive_loaded = get_reg_path_info(path)
+      key = reg_path.join("\\")
+      hive.open(key, ::Win32::Registry::KEY_ALL_ACCESS | @@native_registry_constant) do | reg |
+        values = []
+        begin
+        reg.each_value do |name, type, data|
+          values << [name, type, data]
+        end
+        rescue
+        ensure
+          ensure_hive_unloaded(hive_loaded)
+        end
+        values
+      end
+    end
+
+    def delete_value(path,values)
+      hive, reg_path, hive_name, root_key, hive_loaded = get_reg_path_info(path)
+      key = reg_path.join("\\")
+      Chef::Log.debug("Deleting values in #{path}")
+      hive.open(key, ::Win32::Registry::KEY_ALL_ACCESS | @@native_registry_constant) do | reg |
+        values.each_key { |key|
+          name = "#{key}"
+          # Ensure delete operation is idempotent.
+          if value_exists?(path, key)
+            Chef::Log.debug("Deleting value #{name} in #{path}")
+            reg.delete_value(name)
+          else
+            Chef::Log.debug("Value #{name} in #{path} does not exist, skipping.")
+          end
+        }
+      end
+
+    end
+
+    def create_key(path)
+      hive, reg_path, hive_name, root_key, hive_loaded = get_reg_path_info(path)
+      key = reg_path.join("\\")
+      Chef::Log.debug("Creating registry key #{path}")
+      hive.create(key)
+    end
+
+    def value_exists?(path,value)
+      if key_exists?(path,true)
+
+        hive, reg_path, hive_name, root_key , hive_loaded = get_reg_path_info(path)
+        key = reg_path.join("\\")
+
+        Chef::Log.debug("Attempting to open #{key}");
+        Chef::Log.debug("Native Constant #{@@native_registry_constant}")
+        Chef::Log.debug("Hive #{hive}")
+
+        hive.open(key, ::Win32::Registry::KEY_READ | @@native_registry_constant) do | reg |
+          begin
+            rtn_value = reg[value]
+            return true
+          rescue
+            return false
+          ensure
+            ensure_hive_unloaded(hive_loaded)
+          end
+        end
+
+      end
+      return false
+    end
+
+    # TODO: Does not load user registry...
+    def key_exists?(path, load_hive = false)
+      if load_hive
+        hive, reg_path, hive_name, root_key , hive_loaded = get_reg_path_info(path)
+        key = reg_path.join("\\")
+      else
+        hive = get_hive(path)
+        reg_path = path.split("\\")
+        hive_name = reg_path.shift
+        root_key = reg_path[0]
+        key = reg_path.join("\\")
+        hive_loaded = false
+      end
+
+      begin
+        hive.open(key, ::Win32::Registry::Constants::KEY_READ | @@native_registry_constant )
+        return true
+      rescue
+        return false
+      ensure
+        ensure_hive_unloaded(hive_loaded)
+      end
+    end
+
+    def get_user_hive_location(sid)
+      reg_key = "HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\#{sid}"
+      Chef::Log.debug("Looking for profile at #{reg_key}")
+      if key_exists?(reg_key)
+        return get_value(reg_key,'ProfileImagePath')
+      else
+        return nil
+      end
+
+    end
+
+    def resolve_user_to_sid(username)
+      begin
+        sid = WMI::Win32_UserAccount.find(:first, :conditions => {:name => username}).sid
+        Chef::Log.debug("Resolved user SID to #{sid}")
+        return sid
+      rescue
+        return nil
+      end
+    end
+
+    def hive_loaded?(path)
+      hive = get_hive(path)
+      reg_path = path.split("\\")
+      hive_name = reg_path.shift
+      user_hive = path[0]
+
+      if is_user_hive?(hive)
+        return key_exists?("#{hive_name}\\#{user_hive}")
+      else
+        return true
+      end
+    end
+
+    def is_user_hive?(hive)
+      if hive == ::Win32::Registry::HKEY_USERS
+        return true
+      else
+        return true
+      end
+    end
+
+    def get_reg_path_info(path)
+      hive = get_hive(path)
+      reg_path = path.split("\\")
+      hive_name = reg_path.shift
+      root_key = reg_path[0]
+      hive_loaded = false
+
+      if is_user_hive?(hive) && !key_exists?("#{hive_name}\\#{root_key}")
+        reg_path, hive_loaded = load_user_hive(hive,reg_path,root_key)
+        root_key = reg_path[0]
+        Chef::Log.debug("Resolved user (#{path}) to (#{reg_path.join('/')})")
+      end
+
+      return hive, reg_path, hive_name, root_key, hive_loaded
+    end
+
+    def load_user_hive(hive,reg_path,user_hive)
+      Chef::Log.debug("Reg Path #{reg_path}")
+      # See if the hive is loaded. Logged in users will have a key that is named their SID
+      # if the user has specified the a path by SID and the user is logged in, this function
+      # should not be executed.
+      if is_user_hive?(hive) && !key_exists?("HKU\\#{user_hive}")
+        Chef::Log.debug("The user is not logged in and has not been specified by SID")
+        sid = resolve_user_to_sid(user_hive)
+        Chef::Log.debug("User SID resolved to (#{sid})")
+        # Now that the user has been resolved to a SID, check and see if the hive exists.
+        # If this exists by SID, the user is logged in and we should use that key.
+        # TODO: Replace the username with the sid and send it back because the username
+        # does not exist as the key location.
+        load_reg = false
+        if key_exists?("HKU\\#{sid}")
+          reg_path[0] = sid #use the active profile (user is logged on)
+          Chef::Log.debug("HKEY_USERS Mapped: #{user_hive} -> #{sid}")
+        else
+          Chef::Log.debug("User is not logged in")
+          load_reg = true
+        end
+
+        # The user is not logged in, so we should load the registry from disk
+        if load_reg
+          profile_path = get_user_hive_location(sid)
+          if profile_path != nil
+            ntuser_dat = "#{profile_path}\\NTUSER.DAT"
+            if ::File.exists?(ntuser_dat)
+              priv = Chef::WindowsPrivileged.new
+              if priv.reg_load_key(sid,ntuser_dat)
+                Chef::Log.debug("RegLoadKey(#{sid}, #{user_hive}, #{ntuser_dat})")
+                reg_path[0] = sid
+              else
+                Chef::Log.debug("Failed RegLoadKey(#{sid}, #{user_hive}, #{ntuser_dat})")
+              end
+            end
+          end
+        end
+      end
+
+      return reg_path, load_reg
+
+    end
+
+    private
+    def ensure_hive_unloaded(hive_loaded=false)
+      if(hive_loaded)
+        Chef::Log.debug("Hive was loaded, we really should unload it")
+        unload_hive(path)
+      end
+    end
+  end
+end
+
+module Registry
+  module_function
+  extend Windows::RegistryHelper
+end