chef-server-api/LICENSE chef-server-api/README.rdoc chef-server-api/Rakefile chef-server-api/app/controllers/application.rb chef-server-api/app/controllers/clients.rb chef-server-api/app/controllers/cookbooks.rb chef-server-api/app/controllers/data.rb chef-server-api/app/controllers/data_item.rb chef-server-api/app/controllers/exceptions.rb chef-server-api/app/controllers/main.rb chef-server-api/app/controllers/nodes.rb chef-server-api/app/controllers/roles.rb chef-server-api/app/controllers/search.rb chef-server-api/app/helpers/application_helper.rb chef-server-api/app/helpers/exceptions_helper.rb chef-server-api/app/helpers/global_helpers.rb chef-server-api/app/helpers/nodes_helper.rb chef-server-api/app/helpers/roles_helper.rb chef-server-api/app/views/exceptions/bad_request.json.erb chef-server-api/app/views/exceptions/internal_server_error.html.erb chef-server-api/app/views/exceptions/not_acceptable.html.haml chef-server-api/app/views/exceptions/not_found.html.erb chef-server-api/app/views/exceptions/standard_error.html.erb chef-server-api/app/views/layout/chef_server_api.html.haml chef-server-api/app/views/main/index.html.haml chef-server-api/config/init.rb chef-server-api/config/router.rb chef-server-api/lib/chef-server-api.rb chef-server-api/lib/chef-server-api/merbtasks.rb chef-server-api/lib/chef-server-api/slicetasks.rb chef-server-api/lib/chef-server-api/spectasks.rb chef-server-api/public/images/avatar.png chef-server-api/public/images/indicator.gif chef-server-api/public/images/merb.jpg chef-server-api/public/stylesheets/base.css chef-server-api/public/stylesheets/chef.css chef-server-api/public/stylesheets/themes/bec-green/style.css chef-server-api/public/stylesheets/themes/bec/style.css chef-server-api/public/stylesheets/themes/blue/style.css chef-server-api/public/stylesheets/themes/default/style.css chef-server-api/public/stylesheets/themes/djime-cerulean/style.css chef-server-api/public/stylesheets/themes/kathleene/style.css chef-server-api/public/stylesheets/themes/orange/style.css chef-server-api/public/stylesheets/themes/reidb-greenish/style.css chef-server-api/stubs/app/controllers/application.rb chef-server-api/stubs/app/controllers/main.rb chef-server-webui/LICENSE chef-server-webui/NOTICE chef-server-webui/README.rdoc chef-server-webui/Rakefile chef-server-webui/app/controllers/application.rb chef-server-webui/app/controllers/clients.rb chef-server-webui/app/controllers/cookbook_attributes.rb chef-server-webui/app/controllers/cookbook_definitions.rb chef-server-webui/app/controllers/cookbook_files.rb chef-server-webui/app/controllers/cookbook_libraries.rb chef-server-webui/app/controllers/cookbook_recipes.rb chef-server-webui/app/controllers/cookbook_templates.rb chef-server-webui/app/controllers/cookbooks.rb chef-server-webui/app/controllers/databags.rb chef-server-webui/app/controllers/exceptions.rb chef-server-webui/app/controllers/main.rb chef-server-webui/app/controllers/nodes.rb chef-server-webui/app/controllers/openid_consumer.rb chef-server-webui/app/controllers/roles.rb chef-server-webui/app/controllers/search.rb chef-server-webui/app/controllers/search_entries.rb chef-server-webui/app/controllers/status.rb chef-server-webui/app/helpers/application_helper.rb chef-server-webui/app/helpers/cookbook_attributes_helper.rb chef-server-webui/app/helpers/cookbook_definitions_helper.rb chef-server-webui/app/helpers/cookbook_files_helper.rb chef-server-webui/app/helpers/cookbook_libraries_helper.rb chef-server-webui/app/helpers/cookbook_recipes_helper.rb chef-server-webui/app/helpers/cookbook_templates_helper.rb chef-server-webui/app/helpers/exceptions_helper.rb chef-server-webui/app/helpers/global_helpers.rb chef-server-webui/app/helpers/nodes_helper.rb chef-server-webui/app/helpers/openid_consumer_helper.rb chef-server-webui/app/helpers/openid_register_helper.rb chef-server-webui/app/helpers/openid_server_helper.rb chef-server-webui/app/helpers/openid_server_helpers.rb chef-server-webui/app/helpers/roles_helper.rb chef-server-webui/app/helpers/search_entries_helper.rb chef-server-webui/app/helpers/search_helper.rb chef-server-webui/app/helpers/status_helper.rb chef-server-webui/app/views/clients/_form.html.haml chef-server-webui/app/views/clients/_navigation.html.haml chef-server-webui/app/views/clients/edit.html.haml chef-server-webui/app/views/clients/index.html.haml chef-server-webui/app/views/clients/new.html.haml chef-server-webui/app/views/clients/show.html.haml chef-server-webui/app/views/cookbooks/index.html.haml chef-server-webui/app/views/cookbooks/show.html.haml chef-server-webui/app/views/databags/index.html.haml chef-server-webui/app/views/databags/show.html.haml chef-server-webui/app/views/exceptions/bad_request.json.erb chef-server-webui/app/views/exceptions/internal_server_error.html.erb chef-server-webui/app/views/exceptions/not_acceptable.html.erb chef-server-webui/app/views/exceptions/not_found.html.erb chef-server-webui/app/views/exceptions/standard_error.html.erb chef-server-webui/app/views/layout/chef_server_webui.html.haml chef-server-webui/app/views/layout/login.html.haml chef-server-webui/app/views/main/index.html.erb chef-server-webui/app/views/nodes/_action.html.haml chef-server-webui/app/views/nodes/_form.html.haml chef-server-webui/app/views/nodes/_navigation.html.haml chef-server-webui/app/views/nodes/_resource.html.haml chef-server-webui/app/views/nodes/edit.html.haml chef-server-webui/app/views/nodes/index.html.haml chef-server-webui/app/views/nodes/new.html.haml chef-server-webui/app/views/nodes/show.html.haml chef-server-webui/app/views/openid_consumer/index.html.haml chef-server-webui/app/views/openid_consumer/start.html.haml chef-server-webui/app/views/openid_login/index.html.haml chef-server-webui/app/views/openid_register/index.html.haml chef-server-webui/app/views/openid_register/show.html.haml chef-server-webui/app/views/roles/_form.html.haml chef-server-webui/app/views/roles/_navigation.html.haml chef-server-webui/app/views/roles/edit.html.haml chef-server-webui/app/views/roles/index.html.haml chef-server-webui/app/views/roles/new.html.haml chef-server-webui/app/views/roles/show.html.haml chef-server-webui/app/views/search/_search_form.html.haml chef-server-webui/app/views/search/index.html.haml chef-server-webui/app/views/search/show.html.haml chef-server-webui/app/views/search_entries/index.html.haml chef-server-webui/app/views/search_entries/show.html.haml chef-server-webui/app/views/status/index.html.haml chef-server-webui/config/init.rb chef-server-webui/config/router.rb chef-server-webui/lib/chef-server-webui.rb chef-server-webui/lib/chef-server-webui/merbtasks.rb chef-server-webui/lib/chef-server-webui/slicetasks.rb chef-server-webui/lib/chef-server-webui/spectasks.rb chef-server-webui/public/facebox/README.txt chef-server-webui/public/facebox/b.png chef-server-webui/public/facebox/bl.png chef-server-webui/public/facebox/br.png chef-server-webui/public/facebox/closelabel.gif chef-server-webui/public/facebox/facebox.css chef-server-webui/public/facebox/facebox.js chef-server-webui/public/facebox/loading.gif chef-server-webui/public/facebox/tl.png chef-server-webui/public/facebox/tr.png chef-server-webui/public/images/avatar.png chef-server-webui/public/images/black_big.png chef-server-webui/public/images/indicator.gif chef-server-webui/public/images/merb.jpg chef-server-webui/public/images/toggle-collapse-dark.png chef-server-webui/public/images/toggle-collapse-light.png chef-server-webui/public/images/toggle-collapse.gif chef-server-webui/public/images/toggle-expand-dark.png chef-server-webui/public/images/toggle-expand-light.png chef-server-webui/public/images/toggle-expand.gif chef-server-webui/public/images/treeBuilderImages/Thumbs.db chef-server-webui/public/images/treeBuilderImages/doc.gif chef-server-webui/public/images/treeBuilderImages/docNode.gif chef-server-webui/public/images/treeBuilderImages/docNodeLast.gif chef-server-webui/public/images/treeBuilderImages/docNodeLastFirst.gif chef-server-webui/public/images/treeBuilderImages/folder.gif chef-server-webui/public/images/treeBuilderImages/folderNode.gif chef-server-webui/public/images/treeBuilderImages/folderNodeFirst.gif chef-server-webui/public/images/treeBuilderImages/folderNodeLast.gif chef-server-webui/public/images/treeBuilderImages/folderNodeLastFirst.gif chef-server-webui/public/images/treeBuilderImages/folderNodeOpen.gif chef-server-webui/public/images/treeBuilderImages/folderNodeOpenFirst.gif chef-server-webui/public/images/treeBuilderImages/folderNodeOpenLast.gif chef-server-webui/public/images/treeBuilderImages/folderNodeOpenLastFirst.gif chef-server-webui/public/images/treeBuilderImages/folderOpen.gif chef-server-webui/public/images/treeBuilderImages/vertLine.gif chef-server-webui/public/javascripts/JSONeditor.js chef-server-webui/public/javascripts/chef.js chef-server-webui/public/javascripts/jquery-1.3.2.min.js chef-server-webui/public/javascripts/jquery-ui-1.7.1.custom.min.js chef-server-webui/public/javascripts/jquery.editinline.js chef-server-webui/public/javascripts/jquery.jeditable.mini.js chef-server-webui/public/javascripts/jquery.livequery.js chef-server-webui/public/javascripts/jquery.localscroll.js chef-server-webui/public/javascripts/jquery.scrollTo.js chef-server-webui/public/javascripts/jquery.tools.min.js chef-server-webui/public/javascripts/jquery.treeTable.min.js chef-server-webui/public/stylesheets/base.css chef-server-webui/public/stylesheets/chef.css chef-server-webui/public/stylesheets/images/ui-bg_diagonals-small_0_aaaaaa_40x40.png chef-server-webui/public/stylesheets/images/ui-bg_diagonals-thick_15_444444_40x40.png chef-server-webui/public/stylesheets/images/ui-bg_glass_100_f0f0f0_1x400.png chef-server-webui/public/stylesheets/images/ui-bg_glass_50_99c2ff_1x400.png chef-server-webui/public/stylesheets/images/ui-bg_glass_55_fbf5d0_1x400.png chef-server-webui/public/stylesheets/images/ui-bg_glass_80_e6e6e6_1x400.png chef-server-webui/public/stylesheets/images/ui-bg_glass_95_fef1ec_1x400.png chef-server-webui/public/stylesheets/images/ui-bg_highlight-hard_100_f9f9f9_1x100.png chef-server-webui/public/stylesheets/images/ui-bg_highlight-soft_100_e7eef3_1x100.png chef-server-webui/public/stylesheets/images/ui-icons_222222_256x240.png chef-server-webui/public/stylesheets/images/ui-icons_2694e8_256x240.png chef-server-webui/public/stylesheets/images/ui-icons_2e83ff_256x240.png chef-server-webui/public/stylesheets/images/ui-icons_72a7cf_256x240.png chef-server-webui/public/stylesheets/images/ui-icons_888888_256x240.png chef-server-webui/public/stylesheets/images/ui-icons_cd0a0a_256x240.png chef-server-webui/public/stylesheets/images/ui-icons_ffffff_256x240.png chef-server-webui/public/stylesheets/jquery-ui-1.7.1.custom.css chef-server-webui/public/stylesheets/jquery.treeTable.css chef-server-webui/public/stylesheets/themes/bec-green/style.css chef-server-webui/public/stylesheets/themes/bec/style.css chef-server-webui/public/stylesheets/themes/blue/style.css chef-server-webui/public/stylesheets/themes/default/style.css chef-server-webui/public/stylesheets/themes/djime-cerulean/style.css chef-server-webui/public/stylesheets/themes/kathleene/style.css chef-server-webui/public/stylesheets/themes/orange/style.css chef-server-webui/public/stylesheets/themes/reidb-greenish/style.css chef-server-webui/stubs/app/controllers/application.rb chef-server-webui/stubs/app/controllers/main.rb chef-solr/.document chef-solr/.gitignore chef-solr/README.rdoc chef-solr/Rakefile chef-solr/VERSION chef-solr/bin/chef-solr chef-solr/bin/chef-solr-indexer chef-solr/bin/chef-solr-rebuild chef-solr/chef-solr.gemspec chef-solr/lib/chef/solr.rb chef-solr/lib/chef/solr/application/indexer.rb chef-solr/lib/chef/solr/application/rebuild.rb chef-solr/lib/chef/solr/application/solr.rb chef-solr/lib/chef/solr/index.rb chef-solr/lib/chef/solr/index_actor.rb chef-solr/lib/chef/solr/query.rb chef-solr/solr/solr-home.tar.gz chef-solr/solr/solr-jetty.tar.gz chef-solr/spec/chef/solr/index_spec.rb chef-solr/spec/chef/solr/query_spec.rb chef-solr/spec/chef/solr_spec.rb chef-solr/spec/spec_helper.rb chef/bin/knife chef/lib/chef/api_client.rb chef/lib/chef/certificate.rb chef/lib/chef/data_bag.rb chef/lib/chef/data_bag_item.rb chef/lib/chef/nanite.rb chef/lib/chef/search/query.rb chef/lib/chef/streaming_cookbook_uploader.rb chef/spec/unit/api_client_spec.rb chef/spec/unit/certificate_spec.rb chef/spec/unit/data_bag_item_spec.rb chef/spec/unit/data_bag_spec.rb chef/spec/unit/search/query_spec.rb features/api/clients/create_client_api.feature features/api/clients/delete_client_api.feature features/api/clients/list_clients_api.feature features/api/clients/show_client_api.feature features/api/clients/update_client_api.feature features/api/cookbooks/list_cookbooks_api.feature features/api/cookbooks/show_cookbook_api.feature features/api/cookbooks/show_cookbook_attributes_api.feature features/api/data/create_data_bag_api.feature features/api/data/create_data_bag_item_api.feature features/api/data/delete_data_bag_api.feature features/api/data/delete_data_bag_item.feature features/api/data/list_data_bags.feature features/api/data/show_data_bag_api.feature features/api/data/show_data_bag_item_api.feature features/api/nodes/cookbook_sync_api.feature features/api/search/list_search.feature features/api/search/show_search.feature features/data/cookbooks/node_cookbook_sync/README.rdoc features/data/cookbooks/node_cookbook_sync/attributes/attr_file.rb features/data/cookbooks/node_cookbook_sync/definitions/def_file.rb features/data/cookbooks/node_cookbook_sync/libraries/lib_file.rb features/data/cookbooks/node_cookbook_sync/metadata.rb features/data/cookbooks/node_cookbook_sync/recipes/default.rb features/data/cookbooks/search/recipes/search_data_noblock.rb features/data/cookbooks/show_cookbook/README.rdoc features/data/cookbooks/show_cookbook/attributes/attr_file.rb features/data/cookbooks/show_cookbook/definitions/def_file.rb features/data/cookbooks/show_cookbook/files/default/prime_time.txt features/data/cookbooks/show_cookbook/files/host-latte/prime_time.txt features/data/cookbooks/show_cookbook/files/mac_os_x-10.5/prime_time.txt features/data/cookbooks/show_cookbook/files/mac_os_x/prime_time.txt features/data/cookbooks/show_cookbook/libraries/lib_file.rb features/data/cookbooks/show_cookbook/metadata.rb features/data/cookbooks/show_cookbook/recipes/default.rb features/data/cookbooks/show_cookbook/templates/default/prime_time.txt.erb features/data/cookbooks/show_cookbook/templates/host-latte/prime_time.txt.erb features/data/cookbooks/show_cookbook/templates/mac_os_x-10.5/prime_time.txt.erb features/data/cookbooks/show_cookbook/templates/mac_os_x/prime_time.txt.erb features/data/node-load-test.rb scripts/mac-dev-start @@ -1,3 +1,29 @@ +Mon Sep 27 6:22:00 NZST 2009 + +Release Notes - Chef - Version 0.7.14 + +** Bug + * [CHEF-454] - Centos4 yum provider failure + * [CHEF-565] - dpkg provider fails at packages with a dash in it, causing packages to be re-installed on every chef run + * [CHEF-570] - Portage package provider uses wrong regexp in load_current_resource + * [CHEF-577] - provider.rb doesn't give @definitions a default value of Hash.new, causing epic fail in resource DSL + * [CHEF-588] - RC is missing debugging info in find_preferred_file + * [CHEF-591] - if service doesn't have a status command, process table inspection fails in simple service provider + * [CHEF-593] - deploy resource is not idempotent + * [CHEF-602] - in deploy provider, callback-defined resources are executed in all subsequent callbacks + * [CHEF-603] - deploy: gems.yml support + * [CHEF-604] - deploy: sudo / run command handler support + * [CHEF-614] - LWRP undefined local variable or method `new_resource' + * [CHEF-619] - Mixlib-* gems installed from gemcutter.org have too restrictive permissions + * [CHEF-621] - LWRP dynamic attribute methods are Ruby 1.9 incompatible and cause warnings in 1.8 + * [CHEF-628] - Deploy resource removes newest release instead of oldest + +** Improvement + * [CHEF-620] - LWRP components should be shown in Web UI + * [CHEF-622] - Gem Package resource/provider shouldn't silently ignore the options attribute + * [CHEF-631] - Should create LWRP resources/providers for new_cookbook + + Fri Sep 4 7:25:00 NZST 2009 Release Notes - Chef - Version 0.7.12 CHANGELOG @@ -1,4 +1,4 @@ -gems = %w[chef chef-server-slice chef-server] +gems = %w[chef chef-server-api chef-server-webui chef-server chef-solr] require 'rubygems' require 'cucumber/rake/task' @@ -26,71 +26,136 @@ end desc "Run the rspec tests" task :spec do Dir.chdir("chef") { sh "rake spec" } + Dir.chdir("chef-solr") { sh "rake spec" } end task :default => :spec -def start_dev_environment(type="normal") - @couchdb_server_pid = nil - @chef_server_pid = nil - @chef_indexer_pid = nil - @stompserver_pid = nil - - ccid = fork - if ccid - @couchdb_server_pid = ccid +def start_couchdb(type="normal") + @couchdb_server_pid = nil + cid = fork + if cid + @couchdb_server_pid = cid else exec("couchdb") end +end - scid = fork - if scid - @stompserver_pid = scid +def start_rabbitmq(type="normal") + @rabbitmq_server_pid = nil + cid = fork + if cid + @rabbitmq_server_pid = cid else - exec("stompserver") + exec("rabbitmq-server") end +end - mcid = fork - if mcid # parent - @chef_indexer_pid = mcid - else # child +def configure_rabbitmq(type="normal") + # hack. wait for rabbit to come up. + sleep 2 + + puts `rabbitmqctl add_vhost /nanite` + + # create 'mapper' and 'nanite' users, give them each the password 'testing' + %w[mapper nanite].each do |agent| + puts `rabbitmqctl add_user #{agent} testing` + end + + # grant the mapper user the ability to do anything with the /nanite vhost + # the three regex's map to config, write, read permissions respectively + puts `rabbitmqctl set_permissions -p /nanite mapper ".*" ".*" ".*"` + + # grant the nanite user more limited permissions on the /nanite vhost + puts `rabbitmqctl set_permissions -p /nanite nanite ".*" ".*" ".*"` + + puts `rabbitmqctl list_users` + puts `rabbitmqctl list_vhosts` + puts `rabbitmqctl list_permissions -p /nanite` + +end + +def start_chef_solr(type="normal") + @chef_solr_pid = nil + cid = fork + if cid + @chef_solr_pid = cid + else case type when "normal" - exec("chef-indexer -l debug") + exec("./chef-solr/bin/chef-solr -l debug") when "features" - exec("chef-indexer -c #{File.join(File.dirname(__FILE__), "features", "data", "config", "server.rb")} -l debug") + exec("./chef-solr/bin/chef-solr -c #{File.join(File.dirname(__FILE__), "features", "data", "config", "server.rb")} -l debug") end end +end + +def start_chef_solr_indexer(type="normal") + @chef_solr_indexer = nil + cid = fork + if cid + @chef_solr_indexer_pid = cid + else + case type + when "normal" + exec("./chef-solr/bin/chef-solr-indexer -l debug") + when "features" + exec("./chef-solr/bin/chef-solr-indexer -c #{File.join(File.dirname(__FILE__), "features", "data", "config", "server.rb")} -l debug") + end + end +end +def start_chef_server(type="normal") + @chef_server_pid = nil mcid = fork if mcid # parent @chef_server_pid = mcid else # child case type when "normal" - exec("chef-server -l debug -N -c 2") + exec("./chef-server/bin/chef-server -a thin -l debug -N") when "features" - exec("chef-server -C #{File.join(File.dirname(__FILE__), "features", "data", "config", "server.rb")} -l debug -N -c 2") - + exec("./chef-server/bin/chef-server -a thin -C #{File.join(File.dirname(__FILE__), "features", "data", "config", "server.rb")} -l debug -N") end end +end - puts "Running Chef at #{@chef_server_pid}" - puts "Running Chef Indexer at #{@chef_indexer_pid}" +def start_dev_environment(type="normal") + start_couchdb(type) + start_rabbitmq(type) + configure_rabbitmq(type) + start_chef_solr(type) + start_chef_solr_indexer(type) + start_chef_server(type) puts "Running CouchDB at #{@couchdb_server_pid}" - puts "Running Stompserver at #{@stompserver_pid}" + puts "Running RabbitMQ at #{@rabbitmq_server_pid}" + puts "Running Chef Solr at #{@chef_solr_pid}" + puts "Running Chef Solr Indexer at #{@chef_solr_indexer_pid}" + puts "Running Chef at #{@chef_server_pid}" end def stop_dev_environment - puts "Stopping CouchDB" - Process.kill("KILL", @couchdb_server_pid) - puts "Stopping Stomp server" - Process.kill("KILL", @stompserver_pid) - puts "Stopping Chef Server" - Process.kill("INT", @chef_server_pid) - puts "Stopping Chef Indexer" - Process.kill("INT", @chef_indexer_pid) - puts "\nCouchDB, Stomp, Chef Server and Chef Indexer killed - have a nice day!" + if @chef_server_pid + puts "Stopping Chef" + Process.kill("KILL", @chef_server_pid) + end + if @chef_solr_pid + puts "Stopping Chef Solr" + Process.kill("INT", @chef_solr_pid) + end + if @chef_solr_indexer_pid + puts "Stopping Chef Solr Indexer" + Process.kill("INT", @chef_solr_indexer_pid) + end + if @couchdb_server_pid + puts "Stopping CouchDB" + Process.kill("KILL", @couchdb_server_pid) + end + if @rabbitmq_server_pid + puts "Stopping RabbitMQ" + Process.kill("KILL", @rabbitmq_server_pid) + end + puts "Have a nice day!" end def wait_for_ctrlc @@ -106,7 +171,7 @@ def wait_for_ctrlc end desc "Run a Devel instance of Chef" -task :dev => "dev:install" do +task :dev do start_dev_environment wait_for_ctrlc end @@ -114,12 +179,78 @@ end namespace :dev do desc "Install a test instance of Chef for doing features against" task :features do - gems.each do |dir| - Dir.chdir(dir) { sh "rake install" } - end start_dev_environment("features") wait_for_ctrlc end + + namespace :features do + + namespace :start do + desc "Start CouchDB for testing" + task :couchdb do + start_couchdb("features") + wait_for_ctrlc + end + + desc "Start RabbitMQ for testing" + task :rabbitmq do + start_rabbitmq("features") + configure_rabbitmq("features") + wait_for_ctrlc + end + + desc "Start Chef Solr for testing" + task :chef_solr do + start_chef_solr("features") + wait_for_ctrlc + end + + desc "Start Chef Solr Indexer for testing" + task :chef_solr_indexer do + start_chef_solr_indexer("features") + wait_for_ctrlc + end + + desc "Start Chef Server for testing" + task :chef_server do + start_chef_server("features") + wait_for_ctrlc + end + + end + end + + namespace :start do + desc "Start CouchDB" + task :couchdb do + start_couchdb + wait_for_ctrlc + end + + desc "Start RabbitMQ" + task :rabbitmq do + start_rabbitmq + wait_for_ctrlc + end + + desc "Start Chef Solr" + task :chef_solr do + start_chef_solr + wait_for_ctrlc + end + + desc "Start Chef Solr Indexer" + task :chef_solr_indexer do + start_chef_solr_indexer + wait_for_ctrlc + end + + desc "Start Chef Server" + task :chef_server do + start_chef_server + wait_for_ctrlc + end + end end Cucumber::Rake::Task.new(:features) do |t| @@ -127,12 +258,13 @@ Cucumber::Rake::Task.new(:features) do |t| end namespace :features do + desc "Run cucumber tests for the REST API" Cucumber::Rake::Task.new(:api) do |t| t.profile = "api" end namespace :api do - [ :nodes, :roles].each do |api| + [ :nodes, :roles, :clients ].each do |api| Cucumber::Rake::Task.new(api) do |apitask| apitask.profile = "api_#{api.to_s}" end @@ -144,8 +276,54 @@ namespace :features do end end end + + namespace :nodes do + Cucumber::Rake::Task.new("sync") do |t| + t.profile = "api_nodes_sync" + end + end + + namespace :cookbooks do + desc "Run cucumber tests for the cookbooks portion of the REST API" + Cucumber::Rake::Task.new(:cookbooks) do |t| + t.profile = "api_cookbooks" + end + end + + namespace :data do + desc "Run cucumber tests for the data portion of the REST API" + Cucumber::Rake::Task.new(:data) do |t| + t.profile = "api_data" + end + + desc "Run cucumber tests for deleting data via the REST API" + Cucumber::Rake::Task.new(:delete) do |t| + t.profile = "api_data_delete" + end + desc "Run cucumber tests for adding items via the REST API" + Cucumber::Rake::Task.new(:item) do |t| + t.profile = "api_data_item" + end + end + + namespace :search do + desc "Run cucumber tests for searching via the REST API" + Cucumber::Rake::Task.new(:search) do |t| + t.profile = "api_search" + end + + desc "Run cucumber tests for listing search endpoints via the REST API" + Cucumber::Rake::Task.new(:list) do |t| + t.profile = "api_search_list" + end + desc "Run cucumber tests for searching via the REST API" + Cucumber::Rake::Task.new(:show) do |t| + t.profile = "api_search_show" + end + end end + desc "Run cucumber tests for the chef client" Cucumber::Rake::Task.new(:client) do |t| t.profile = "client" end @@ -154,8 +332,23 @@ namespace :features do Cucumber::Rake::Task.new(:roles) do |t| t.profile = "client_roles" end + + Cucumber::Rake::Task.new(:run_interval) do |t| + t.profile = "client_run_interval" + end end + desc "Run cucumber tests for the cookbooks" + Cucumber::Rake::Task.new(:cookbooks) do |t| + t.profile = "cookbooks" + end + + desc "Run cucumber tests for the recipe language" + Cucumber::Rake::Task.new(:language) do |t| + t.profile = "language" + end + + desc "Run cucumber tests for searching in recipes" Cucumber::Rake::Task.new(:search) do |t| t.profile = "search" end @@ -173,21 +366,50 @@ namespace :features do Cucumber::Rake::Task.new(:lwrp) do |t| t.profile = "lwrp" end + + desc "Run cucumber tests for providers" + Cucumber::Rake::Task.new(:provider) do |t| + t.profile = "provider" + end + namespace :provider do - Cucumber::Rake::Task.new(:template) do |t| - t.profile = "provider_template" + desc "Run cucumber tests for deploy resources" + Cucumber::Rake::Task.new(:deploy) do |t| + t.profile = "provider_deploy" + end + + desc "Run cucumber tests for directory resources" + Cucumber::Rake::Task.new(:directory) do |t| + t.profile = "provider_directory" + end + + desc "Run cucumber tests for execute resources" + Cucumber::Rake::Task.new(:execute) do |t| + t.profile = "provider_execute" end + desc "Run cucumber tests for file resources" + Cucumber::Rake::Task.new(:file) do |t| + t.profile = "provider_file" + end + + desc "Run cucumber tests for remote_file resources" Cucumber::Rake::Task.new(:remote_file) do |t| t.profile = "provider_remote_file" end + + desc "Run cucumber tests for template resources" + Cucumber::Rake::Task.new(:template) do |t| + t.profile = "provider_template" + end Cucumber::Rake::Task.new(:git) do |t| t.profile = "provider_git" end namespace :package do + desc "Run cucumber tests for macports packages" Cucumber::Rake::Task.new(:macports) do |t| t.profile = "provider_package_macports" end Rakefile @@ -18,7 +18,7 @@ require 'chef' unless defined?(Chef) include FileUtils GEM = "chef-server" -CHEF_SERVER_VERSION = "0.7.12" +CHEF_SERVER_VERSION = "0.8.0" AUTHOR = "Opscode" EMAIL = "chef@opscode.com" HOMEPAGE = "http://wiki.opscode.com/display/chef" chef-server/Rakefile @@ -26,7 +26,8 @@ require "rubygems" require "merb-core" -[ 'chef', 'chef-server-slice' ].each do |lib| +[ 'chef', 'chef-server-api' ].each do |lib| + $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib"))) library = File.join(File.dirname(__FILE__), "..", "..", lib, "lib", "#{lib}.rb") require library if File.exists?(library) end @@ -50,7 +51,7 @@ if ARGV[0] && ARGV[0] =~ /^[^-]/ ARGV.push "-H" end unless %w[-a --adapter -i --irb-console -r --script-runner].any? { |o| ARGV.index(o) } - ARGV.push *%w[-a mongrel] + ARGV.push *%w[-a thin] end ARGV.push *[ "-I", File.join(__DIR__, "config", "init.rb") ] ARGV.push *[ "-m", __DIR__] chef-server/bin/chef-server @@ -4,8 +4,10 @@ require 'chef' Chef::Config.from_file(File.join("/etc", "chef", "server.rb")) -Merb::Config.setup(:merb_root => File.expand_path(File.dirname(__FILE__)), - :environment => ENV['RACK_ENV'], :init_file => File.dirname(__FILE__) / "config/init.rb") +Merb::Config.setup(:merb_root => File.expand_path(File.dirname(__FILE__)), + :environment => ENV['RACK_ENV'], + :fork_for_class_load => false, + :init_file => File.dirname(__FILE__) / "config/init.rb") Merb.environment = Merb::Config[:environment] Merb.root = Merb::Config[:merb_root] Merb::BootLoader.run chef-server/config.ru @@ -1,13 +1,24 @@ # dependencies are generated using a strict version, don't forget to edit the dependency versions when upgrading. merb_gems_version = "> 1.0" +%w{chef chef-server-api chef-solr}.each do |dep| + $:.unshift(File.join(File.dirname(__FILE__), "..", "..", dep, "lib")) +end + +begin + require 'chef' + require 'chef-server-api' +rescue +end + # For more information about each component, please read http://wiki.merbivore.com/faqs/merb_components dependency "merb-core", merb_gems_version dependency "merb-assets", merb_gems_version dependency "merb-helpers", merb_gems_version dependency "merb-slices", merb_gems_version if defined?(CHEF_SERVER_VERSION) - dependency "chef-server-slice", CHEF_SERVER_VERSION unless defined?(ChefServerSlice) + dependency "chef-server-api", CHEF_SERVER_VERSION unless defined?(ChefServerApi) else - dependency "chef-server-slice" unless defined?(ChefServerSlice) + dependency "chef-server-api" unless defined?(ChefServerApi) end + chef-server/config/dependencies.rb @@ -4,7 +4,6 @@ Merb::Config.use { |c| c[:reload_templates] = true c[:reload_classes] = true c[:reload_time] = 0.5 - c[:ignore_tampered_cookies] = true c[:log_auto_flush ] = true c[:log_level] = :debug c[:log_stream] = Chef::Config[:log_location] chef-server/config/environments/development.rb @@ -2,6 +2,7 @@ Merb.logger.info("Loaded PRODUCTION Environment...") Merb::Config.use { |c| c[:exception_details] = false c[:reload_classes] = false + c[:log_auto_flush] = true c[:log_level] = Chef::Config[:log_level] c[:log_stream] = Chef::Config[:log_location] # or redirect logger using IO handle chef-server/config/environments/production.rb @@ -1,5 +1,5 @@ # Go to http://wiki.merbivore.com/pages/init-rb - + require 'config/dependencies.rb' unless defined?(Chef) gem "chef", "=" + CHEF_SERVER_VERSION if CHEF_SERVER_VERSION @@ -11,13 +11,10 @@ use_template_engine :haml Merb::Config.use do |c| c[:use_mutex] = false - c[:session_id_key] = '_chef_server_session_id' - c[:session_secret_key] = Chef::Config.manage_secret_key - c[:session_store] = 'cookie' - c[:exception_details] = true - c[:reload_classes] = false c[:log_level] = Chef::Config[:log_level] - c[:log_stream] = Chef::Config[:log_location] + if Chef::Config[:log_location].kind_of?(String) + c[:log_file] = Chef::Config[:log_location] + end end Merb::BootLoader.before_app_loads do @@ -25,6 +22,6 @@ Merb::BootLoader.before_app_loads do end Merb::BootLoader.after_app_loads do - # This will get executed after your app's classes have been loaded. - OpenID::Util.logger = Merb.logger + # This will get executed after your app's classes have been loaded. OpenID::Util.logger = Merb.logger end + chef-server/config/init.rb @@ -1,3 +1,5 @@ +$: << File.join(File.dirname(__FILE__)) + # use PathPrefix Middleware if :path_prefix is set in Merb::Config if prefix = ::Merb::Config[:path_prefix] use Merb::Rack::PathPrefix, prefix chef-server/config/rack.rb @@ -29,16 +29,11 @@ Merb.logger.info("Compiling routes...") Merb::Router.prepare do # RESTful routes # resources :posts - + # Adds the required routes for merb-auth using the password slice # slice(:merb_auth_slice_password, :name_prefix => nil, :path_prefix => "") - slice(:chef_server_slice) - # This is the default route for /:controller/:action/:id - # This is fine for most cases. If you're heavily using resource-based - # routes, you may want to comment/remove this line to prevent - # clients from calling your create or destroy actions with a GET - default_routes - - # Change this for your home page to be available at / - # match('/').to(:controller => 'whatever', :action =>'index') + + slice(:chef_server_api) + # slice(:chef_server_webui, :path_prefix => "html") + end chef-server/config/router.rb @@ -4,7 +4,7 @@ require 'rake/rdoctask' require './tasks/rspec.rb' GEM = "chef" -CHEF_VERSION = "0.7.12" +CHEF_VERSION = "0.8.0" AUTHOR = "Adam Jacob" EMAIL = "adam@opscode.com" HOMEPAGE = "http://wiki.opscode.com/display/chef" @@ -23,13 +23,11 @@ spec = Gem::Specification.new do |s| s.homepage = HOMEPAGE s.add_dependency "mixlib-config", ">= 1.0.12" - s.add_dependency "ohai", ">= 0.3.4" - %w{mixlib-cli mixlib-log ruby-openid - json erubis extlib - stomp}.each { |gem| s.add_dependency gem } + s.add_dependency "ohai", ">= 0.3.6" + %w{mixlib-cli mixlib-log mixlib-authentication json erubis extlib amqp thor ruby-hmac}.each { |gem| s.add_dependency gem } s.bindir = "bin" - s.executables = %w( chef-client chef-solo ) + s.executables = %w( chef-client chef-solo knife ) s.require_path = 'lib' s.files = %w(LICENSE README.rdoc) + Dir.glob("{distro,lib}/**/*") end chef/Rakefile @@ -18,9 +18,9 @@ # See the License for the specific language governing permissions and # limitations under the License. -$: << File.join(File.dirname(__FILE__), "..", "lib") +$:.unshift(File.join(File.dirname(__FILE__), "..", "lib")) require 'rubygems' require 'chef/application/client' -Chef::Application::Client.new.run \ No newline at end of file +Chef::Application::Client.new.run chef/bin/chef-client @@ -18,7 +18,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -$: << File.join(File.dirname(__FILE__), "..", "lib") +$:.unshift(File.join(File.dirname(__FILE__), "..", "lib")) require 'rubygems' require 'chef/application/solo' chef/bin/chef-solo @@ -27,7 +27,7 @@ require 'chef/config' Dir[File.join(File.dirname(__FILE__), 'chef/mixin/**/*.rb')].sort.each { |lib| require lib } class Chef - VERSION = '0.7.12' + VERSION = '0.8.0' end # Adds a Dir.glob to Ruby 1.8.5, for compat chef/lib/chef.rb @@ -153,6 +153,11 @@ class Chef::Application::Client < Chef::Application end end end + + def configure_logging + super + Mixlib::Authentication::Log.logger = Chef::Log.logger + end # Setup an instance of the chef client # Why is this so ugly? surely the client should just read out of chef::config instead of needing the values to be assigned like this.. chef/lib/chef/application/client.rb @@ -15,4 +15,5 @@ # See the License for the specific language governing permissions and # limitations under the License. -require 'chef/application' \ No newline at end of file +require 'chef/application' + chef/lib/chef/application/server.rb @@ -47,9 +47,14 @@ class Chef @json_attribs = nil @node_name = nil @node_exists = true - Ohai::Log.logger = Chef::Log.logger + Mixlib::Authentication::Log.logger = Ohai::Log.logger = Chef::Log.logger @ohai = Ohai::System.new - @rest = Chef::REST.new(Chef::Config[:registration_url]) + @ohai_has_run = false + if File.exists?(Chef::Config[:client_key]) + @rest = Chef::REST.new(Chef::Config[:chef_server_url]) + else + @rest = Chef::REST.new(Chef::Config[:chef_server_url], nil, nil) + end end # Do a full run for this Chef::Client. Calls: @@ -76,15 +81,9 @@ class Chef determine_node_name register - authenticate build_node(@node_name) save_node - sync_library_files - sync_provider_files - sync_resource_files - sync_attribute_files - sync_definitions - sync_recipes + sync_cookbooks save_node converge save_node @@ -123,9 +122,14 @@ class Chef end def determine_node_name - run_ohai + run_ohai unless safe_name && node_name - @node_name ||= @ohai[:fqdn] ? @ohai[:fqdn] : @ohai[:hostname] + if Chef::Config[:node_name] + @node_name = Chef::Config[:node_name] + else + @node_name ||= @ohai[:fqdn] ? @ohai[:fqdn] : @ohai[:hostname] + Chef::Config[:node_name] = @node_name + end @safe_name = @node_name.gsub(/\./, '_') end @node_name @@ -184,68 +188,22 @@ class Chef @node[:tags] = Array.new unless @node.attribute?(:tags) @node end - - # If this node has been registered before, this method will fetch the current registration - # data. - # - # If it has not, we register it by calling create_registration. - # + + # # === Returns # true:: Always returns true def register - determine_node_name unless @node_name - Chef::Log.debug("Registering #{@safe_name} for an openid") - - begin - if @rest.get_rest("registrations/#{@safe_name}") - @secret = Chef::FileCache.load(File.join("registration", @safe_name)) - end - rescue Net::HTTPServerException => e - case e.message - when /^404/ - create_registration - else - raise - end - rescue Chef::Exceptions::FileNotFound - Chef::Application.fatal! "A remote registration already exists for #{@safe_name}, however the local shared secret does not exist." + - " To remedy this, you could delete the registration via webUI/REST, change the node_name option in config.rb" + - " (or use the -N/--node-name option to the CLI) or" + - " copy the old shared secret to #{File.join(Chef::Config[:file_cache_path], 'registration', @safe_name)}", 3 + if File.exists?(Chef::Config[:validation_key]) + @vr = Chef::REST.new(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]) + @vr.register(@node_name, Chef::Config[:client_key]) + else + Chef::Log.debug("Validation key #{Chef::Config[:validation_key]} is not present - skipping registration") end - + # We now have the client key, and should use it from now on. + @rest = Chef::REST.new(Chef::Config[:chef_server_url]) true end - # Generates a random secret, stores it in the Chef::Filestore with the "registration" key, - # and posts our nodes registration information to the server. - # - # === Returns - # true:: Always returns true - def create_registration - @secret = random_password(500) - Chef::FileCache.store(File.join("registration", @safe_name), @secret) - @rest.post_rest("registrations", { :id => @safe_name, :password => @secret, :validation_token => @validation_token }) - true - end - - # Authenticates the node via OpenID. - # - # === Returns - # true:: Always returns true - def authenticate - determine_node_name unless @node_name - Chef::Log.debug("Authenticating #{@safe_name} via openid") - response = @rest.post_rest('openid/consumer/start', { - "openid_identifier" => "#{Chef::Config[:openid_url]}/openid/server/node/#{@safe_name}", - "submit" => "Verify" - }) - @rest.post_rest( - "#{Chef::Config[:openid_url]}#{response["action"]}", - { "password" => @secret } - ) - end - # Update the file caches for a given cache segment. Takes a segment name # and a hash that matches one of the cookbooks/_attribute_files style # remote file listings. @@ -253,125 +211,83 @@ class Chef # === Parameters # segment<String>:: The cache segment to update # remote_list<Hash>:: A cookbooks/_attribute_files style remote file listing - def update_file_cache(segment, remote_list) - # We need the list of known good attribute files, so we can delete any that are - # just laying about. + def update_file_cache(cookbook_name, parts) + Chef::Log.debug("Synchronizing cookbook #{cookbook_name}") + file_canonical = Hash.new - - remote_list.each do |rf| - cache_file = File.join("cookbooks", rf['cookbook'], segment, rf['name']) - file_canonical[cache_file] = true - # For back-compat between older clients and new chef servers - rf['checksum'] ||= nil - - current_checksum = nil - if Chef::FileCache.has_key?(cache_file) - current_checksum = checksum(Chef::FileCache.load(cache_file, false)) - end + [ "recipes", "attributes", "definitions", "libraries", "resources", "providers" ].each do |segment| + remote_list = parts.has_key?(segment) ? parts[segment] : [] - rf_url = generate_cookbook_url( - rf['name'], - rf['cookbook'], - segment, - @node, - current_checksum ? { 'checksum' => current_checksum } : nil - ) - Chef::Log.debug(rf_url) + # segement = cookbook segment + # remote_list = list of file hashes + # + # We need the list of known good attribute files, so we can delete any that are + # just laying about. + + remote_list.each do |rf| + cache_file = File.join("cookbooks", cookbook_name, segment, rf['name']) + file_canonical[cache_file] = true - if current_checksum != rf['checksum'] - changed = true - begin - raw_file = @rest.get_rest(rf_url, true) - rescue Net::HTTPRetriableError => e - if e.response.kind_of?(Net::HTTPNotModified) - changed = false - Chef::Log.debug("Cache file #{cache_file} is unchanged") - else - raise e - end + # For back-compat between older clients and new chef servers + rf['checksum'] ||= nil + + current_checksum = nil + if Chef::FileCache.has_key?(cache_file) + current_checksum = checksum(Chef::FileCache.load(cache_file, false)) end - if changed - Chef::Log.info("Storing updated #{cache_file} in the cache.") - Chef::FileCache.move_to(raw_file.path, cache_file) + rf_url = generate_cookbook_url( + rf['name'], + cookbook_name, + segment, + @node, + current_checksum ? { 'checksum' => current_checksum } : nil + ) + if current_checksum != rf['checksum'] + changed = true + begin + raw_file = @rest.get_rest(rf_url, true) + rescue Net::HTTPRetriableError => e + if e.response.kind_of?(Net::HTTPNotModified) + changed = false + Chef::Log.debug("Cache file #{cache_file} is unchanged") + else + raise e + end + end + + if changed + Chef::Log.info("Storing updated #{cache_file} in the cache.") + Chef::FileCache.move_to(raw_file.path, cache_file) + end end end - end - - Chef::FileCache.list.each do |cache_file| - if cache_file.match("cookbooks/.+?/#{segment}") - unless file_canonical[cache_file] - Chef::Log.info("Removing #{cache_file} from the cache; it is no longer on the server.") - Chef::FileCache.delete(cache_file) + + Chef::FileCache.list.each do |cache_file| + if cache_file =~ /^cookbooks\/(recipes|attributes|definitions|libraries)\// + unless file_canonical[cache_file] + Chef::Log.info("Removing #{cache_file} from the cache; it is no longer on the server.") + Chef::FileCache.delete(cache_file) + end end end + end end - - # Gets all the attribute files included in all the cookbooks available on the server, - # and executes them. - # - # === Returns - # true:: Always returns true - def sync_attribute_files - Chef::Log.debug("Synchronizing attributes") - update_file_cache("attributes", @rest.get_rest("cookbooks/_attribute_files?node=#{@node.name}")) - true - end - - # Gets all the library files included in all the cookbooks available on the server, - # and loads them. - # - # === Returns - # true:: Always returns true - def sync_library_files - Chef::Log.debug("Synchronizing libraries") - update_file_cache("libraries", @rest.get_rest("cookbooks/_library_files?node=#{@node.name}")) - true - end - - # Gets all the provider files included in all the cookbooks available on the server, - # and loads them. - # - # === Returns - # true:: Always returns true - def sync_provider_files - Chef::Log.debug("Synchronizing providers") - update_file_cache("providers", @rest.get_rest("cookbooks/_provider_files?node=#{@node.name}")) - true - end - - # Gets all the resource files included in all the cookbooks available on the server, - # and loads them. - # - # === Returns - # true:: Always returns true - def sync_resource_files - Chef::Log.debug("Synchronizing resources") - update_file_cache("resources", @rest.get_rest("cookbooks/_resource_files?node=#{@node.name}")) - true - end - # Gets all the definition files included in all the cookbooks available on the server, - # and loads them. + # Synchronizes all the cookbooks from the chef-server. # # === Returns # true:: Always returns true - def sync_definitions - Chef::Log.debug("Synchronizing definitions") - update_file_cache("definitions", @rest.get_rest("cookbooks/_definition_files?node=#{@node.name}")) - end - - # Gets all the recipe files included in all the cookbooks available on the server, - # and loads them. - # - # === Returns - # true:: Always returns true - def sync_recipes - Chef::Log.debug("Synchronizing recipes") - update_file_cache("recipes", @rest.get_rest("cookbooks/_recipe_files?node=#{@node.name}")) + def sync_cookbooks + Chef::Log.debug("Synchronizing cookbooks") + cookbook_hash = @rest.get_rest("nodes/#{@safe_name}/cookbooks") + Chef::Log.debug("Cookbooks to load: #{cookbook_hash.inspect}") + cookbook_hash.each do |cookbook_name, parts| + update_file_cache(cookbook_name, parts) + end end # Updates the current node configuration on the server. @@ -407,15 +323,6 @@ class Chef cr.converge true end - - protected - # Generates a random password of "len" length. - def random_password(len) - chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a - newpass = "" - 1.upto(len) { |i| newpass << chars[rand(chars.size-1)] } - newpass - end end end chef/lib/chef/client.rb @@ -17,6 +17,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +require 'chef/log' require 'mixlib/config' class Chef @@ -54,13 +55,24 @@ class Chef :template_url, :remotefile_url, :search_url, + :chef_server_url, :role_url ].each do |u| c[u] = url end end url end - + + # When you are using ActiveSupport, they monkey-patch 'daemonize' into Kernel. + # So while this is basically identical to what method_missing would do, we pull + # it up here and get a real method written so that things get dispatched + # properly. + config_attr_writer :daemonize do |v| + configure do |c| + c[:daemonize] = v + end + end + # Override the config dispatch to set the value of log_location configuration option # # === Parameters @@ -86,12 +98,10 @@ class Chef authorized_openid_identifiers nil authorized_openid_providers nil - chef_server_url nil cookbook_path [ "/var/chef/site-cookbooks", "/var/chef/cookbooks" ] couchdb_database "chef" couchdb_url "http://localhost:5984" couchdb_version nil - daemonize nil delay 0 executable_path ENV['PATH'] ? ENV['PATH'].split(File::PATH_SEPARATOR) : [] file_cache_path "/var/chef/cache" @@ -118,8 +128,9 @@ class Chef queue_retry_count 5 queue_retry_delay 5 queue_user "" - queue_prefix nil + chef_server_url "http://localhost:4000" registration_url "http://localhost:4000" + client_url "http://localhost:4042" remotefile_url "http://localhost:4000" rest_timeout 60 run_command_stderr_timeout 120 @@ -137,5 +148,37 @@ class Chef role_path "/var/chef/roles" role_url "http://localhost:4000" recipe_url nil + solr_url "http://localhost:8983" + solr_jetty_path "/var/chef/solr-jetty" + solr_data_path "/var/chef/solr/data" + solr_home_path "/var/chef/solr" + solr_heap_size "256M" + solr_java_opts nil + nanite_host '0.0.0.0' + nanite_port '5672' + nanite_user 'nanite' + nanite_pass 'testing' + nanite_vhost '/nanite' + nanite_identity nil + nanite_persistent_mapper false + + client_key "/etc/chef/client.pem" + validation_key "/etc/chef/validation.pem" + validation_client_name "chef-validator" + web_ui_client_name "chef-webui" + web_ui_key "/etc/chef/webui.pem" + + # Server Signing CA + # + # In truth, these don't even have to change + signing_ca_cert "/var/chef/ca/cert.pem" + signing_ca_key "/var/chef/ca/key.pem" + signing_ca_country "US" + signing_ca_state "Washington" + signing_ca_location "Seattle" + signing_ca_org "Chef User" + signing_ca_domain "opensource.opscode.com" + signing_ca_email "opensource-cert@opscode.com" + end end chef/lib/chef/config.rb @@ -1,5 +1,6 @@ # # Author:: Adam Jacob (<adam@opscode.com>) +# Author:: Nuo Yan (<nuo@opscode.com>) # Author:: Christopher Walters (<cw@opscode.com>) # Copyright:: Copyright (c) 2008 Opscode, Inc. # License:: Apache License, Version 2.0 chef/lib/chef/cookbook.rb @@ -379,6 +379,7 @@ class Chef self.maintainer o['maintainer'] if o.has_key?('maintainer') self.maintainer_email o['maintainer_email'] if o.has_key?('maintainer_email') self.license o['license'] if o.has_key?('license') + self.version o['version'] if o.has_key?('version') self.platforms = o['platforms'] if o.has_key?('platforms') self.dependencies = o['dependencies'] if o.has_key?('dependencies') self.recommendations = o['recommendations'] if o.has_key?('recommendations') chef/lib/chef/cookbook/metadata.rb @@ -21,40 +21,82 @@ require 'chef/rest' require 'chef/log' require 'digest/sha2' require 'json' +require 'chef/nanite' + +# We want to fail on create if uuidtools isn't installed +begin + require 'uuidtools' +rescue LoadError +end class Chef class CouchDB include Chef::Mixin::ParamsValidate - def initialize(url=nil) + def initialize(url=nil, db=Chef::Config[:couchdb_database]) url ||= Chef::Config[:couchdb_url] - @rest = Chef::REST.new(url) + @db = db + @rest = Chef::REST.new(url, nil, nil) end - + + def couchdb_database(args=nil) + if args + @db = args + else + @db + end + end + + def create_id_map + create_design_document( + "id_map", + { + "version" => 1, + "language" => "javascript", + "views" => { + "name_to_id" => { + "map" => <<-EOJS + function(doc) { + emit([ doc.chef_type, doc.name], doc._id); + } + EOJS + }, + "id_to_name" => { + "map" => <<-EOJS + function(doc) { + emit(doc._id, [ doc.chef_type, doc.name ]); + } + EOJS + } + } + } + ) + end + def create_db @database_list = @rest.get_rest("_all_dbs") - unless @database_list.detect { |db| db == Chef::Config[:couchdb_database] } - response = @rest.put_rest(Chef::Config[:couchdb_database], Hash.new) + unless @database_list.detect { |db| db == couchdb_database } + response = @rest.put_rest(couchdb_database, Hash.new) end - Chef::Config[:couchdb_database] + couchdb_database end def create_design_document(name, data) create_db to_update = true begin - old_doc = @rest.get_rest("#{Chef::Config[:couchdb_database]}/_design%2F#{name}") + old_doc = @rest.get_rest("#{couchdb_database}/_design/#{name}") if data["version"] != old_doc["version"] data["_rev"] = old_doc["_rev"] Chef::Log.debug("Updating #{name} views") else to_update = false end - rescue - Chef::Log.debug("Creating #{name} views for the first time") + rescue + Chef::Log.debug("Creating #{name} views for the first time because: #{$!}") end if to_update - @rest.put_rest("#{Chef::Config[:couchdb_database]}/_design%2F#{name}", data) + @rest.put_rest("#{couchdb_database}/_design%2F#{name}", data) end true end @@ -70,7 +112,27 @@ class Chef :object => { :respond_to => :to_json }, } ) - @rest.put_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}", object) + r = get_view("id_map", "name_to_id", :key => [ obj_type, name ]) + uuid = nil + if r["rows"].length == 1 + uuid = r["rows"][0]["id"] + else + uuid = UUIDTools::UUID.random_create.to_s + end + + r = @rest.put_rest("#{couchdb_database}/#{uuid}", object) + Chef::Log.info("Sending #{uuid} to Nanite for indexing..") + n = Chef::Nanite.push( + "/index/add", + { + :id => uuid, + :database => couchdb_database, + :type => obj_type, + :item => object + }, + :persistent => true + ) + r end def load(obj_type, name) @@ -84,7 +146,9 @@ class Chef :name => { :kind_of => String }, } ) - @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}") + doc = find_by_name(obj_type, name) + doc.couchdb = self if doc.respond_to?(:couchdb) + doc end def delete(obj_type, name, rev=nil) @@ -98,15 +162,28 @@ class Chef :name => { :kind_of => String }, } ) + del_id = nil + last_obj, obj_id = find_by_name(obj_type, name, true) unless rev - last_obj = @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}") if last_obj.respond_to?(:couchdb_rev) rev = last_obj.couchdb_rev else rev = last_obj['_rev'] end end - @rest.delete_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}?rev=#{rev}") + r = @rest.delete_rest("#{couchdb_database}/#{obj_id}?rev=#{rev}") + r.couchdb = self if r.respond_to?(:couchdb) + Chef::Log.info("Sending #{obj_id} to Nanite for deletion..") + n = Chef::Nanite.push( + "/index/delete", + { + :id => obj_id, + :database => couchdb_database, + :type => obj_type + }, + :persistent => true + ) + r end def list(view, inflate=false) @@ -119,10 +196,13 @@ class Chef } ) if inflate - @rest.get_rest(view_uri(view, "all")) + r = @rest.get_rest(view_uri(view, "all")) + r["rows"].each { |i| i["value"].couchdb = self if i["value"].respond_to?(:couchdb=) } + r else - @rest.get_rest(view_uri(view, "all_id")) + r = @rest.get_rest(view_uri(view, "all_id")) end + r end def has_key?(obj_type, name) @@ -137,13 +217,25 @@ class Chef } ) begin - @rest.get_rest("#{Chef::Config[:couchdb_database]}/#{obj_type}_#{safe_name(name)}") + find_by_name(obj_type, name) true rescue false end end + def find_by_name(obj_type, name, with_id=false) + r = get_view("id_map", "name_to_id", :key => [ obj_type, name ], :include_docs => true) + if r["rows"].length == 0 + raise Chef::Exceptions::CouchDBNotFound, "Cannot find #{obj_type} #{name} in CouchDB!" + end + if with_id + [ r["rows"][0]["doc"], r["rows"][0]["id"] ] + else + r["rows"][0]["doc"] + end + end + def get_view(design, view, options={}) view_string = view_uri(design, view) view_string << "?" if options.length != 0 @@ -151,18 +243,23 @@ class Chef options.each { |k,v| view_string << "#{first ? '' : '&'}#{k}=#{URI.escape(v.to_json)}"; first = false } @rest.get_rest(view_string) end + + def bulk_get(*to_fetch) + response = @rest.post_rest("#{couchdb_database}/_all_docs?include_docs=true", { "keys" => to_fetch.flatten }) + response["rows"].collect { |r| r["doc"] } + end def view_uri(design, view) Chef::Config[:couchdb_version] ||= @rest.run_request(:GET, URI.parse(@rest.url + "/"), - false, + {}, 10, false)["version"].gsub(/-.+/,"").to_f case Chef::Config[:couchdb_version] when 0.8 - "#{Chef::Config[:couchdb_database]}/_view/#{design}/#{view}" + "#{couchdb_database}/_view/#{design}/#{view}" else - "#{Chef::Config[:couchdb_database]}/_design/#{design}/_view/#{view}" + "#{couchdb_database}/_design/#{design}/_view/#{view}" end end @@ -171,6 +268,6 @@ class Chef def safe_name(name) name.gsub(/\./, "_") end - + end end chef/lib/chef/couchdb.rb @@ -32,5 +32,8 @@ class Chef class Group < RuntimeError; end class Link < RuntimeError; end class Mount < RuntimeError; end + class CouchDBNotFound < RuntimeError; end + class PrivateKeyMissing < RuntimeError; end + class CannotWritePrivateKey < RuntimeError; end end end chef/lib/chef/exceptions.rb @@ -74,6 +74,8 @@ class Chef ] file_list_str = file_list.keys.join("\n") + Chef::Log.debug("Searching for preferred file in\n#{file_list_str}") + preferences.each do |pref| Chef::Log.debug("Looking for #{pref}") matcher = /^(.+#{pref})$/ chef/lib/chef/mixin/find_preferred_file.rb @@ -30,19 +30,28 @@ class Chef else new_url = "cookbooks/#{cookbook}/#{type}?" new_url += "id=#{url}" - platform, version = Chef::Platform.find_platform_and_version(node) - if type == "files" || type == "templates" - new_url += "&platform=#{platform}&version=#{version}&fqdn=#{node[:fqdn]}&node_name=#{node.name}" - end - if args - args.each do |key, value| - new_url += "&#{key}=#{value}" - end - end + new_url = generate_cookbook_url_from_uri(new_url, node, args) end Chef::Log.debug("generated cookbook url: #{new_url}") return new_url end + + def generate_cookbook_url_from_uri(uri, node, args=nil) + platform, version = Chef::Platform.find_platform_and_version(node) + uri =~ /cookbooks\/(.+?)\/(.+)\?/ + cookbook = $1 + type = $2 + if type == "files" || type == "templates" + uri += "&platform=#{platform}&version=#{version}&fqdn=#{node[:fqdn]}&node_name=#{node.name}" + end + if args + args.each do |key, value| + uri += "&#{key}=#{value}" + end + end + + uri + end end end chef/lib/chef/mixin/generate_url.rb @@ -16,6 +16,8 @@ # limitations under the License. # +require 'chef/search/query' + class Chef module Mixin module Language @@ -73,6 +75,10 @@ class Chef has_platform end + + def search(*args, &block) + Chef::Search::Query.new.search(*args, &block) + end end end chef/lib/chef/mixin/language.rb @@ -20,12 +20,14 @@ require 'chef/recipe' require 'chef/resource' require 'chef/mixin/convert_to_class_name' +require 'chef/mixin/language' class Chef module Mixin module RecipeDefinitionDSLCore include Chef::Mixin::ConvertToClassName + include Chef::Mixin::Language def method_missing(method_symbol, *args, &block) # If we have a definition that matches, we want to use that instead. This should chef/lib/chef/mixin/recipe_definition_dsl_core.rb @@ -21,7 +21,7 @@ require 'chef/mixin/check_helper' require 'chef/mixin/params_validate' require 'chef/mixin/from_file' require 'chef/couchdb' -require 'chef/queue' +require 'chef/rest' require 'chef/run_list' require 'chef/node/attribute' require 'extlib' @@ -30,14 +30,14 @@ require 'json' class Chef class Node - attr_accessor :attribute, :recipe_list, :couchdb_rev, :run_state, :run_list, :override, :default + attr_accessor :attribute, :recipe_list, :couchdb_rev, :couchdb_id, :run_state, :run_list, :override, :default include Chef::Mixin::CheckHelper include Chef::Mixin::FromFile include Chef::Mixin::ParamsValidate DESIGN_DOCUMENT = { - "version" => 8, + "version" => 9, "language" => "javascript", "views" => { "all" => { @@ -120,7 +120,7 @@ class Chef } # Create a new Chef::Node object. - def initialize() + def initialize @name = nil @attribute = Mash.new @@ -129,7 +129,9 @@ class Chef @run_list = Chef::RunList.new @couchdb_rev = nil + @couchdb_id = nil @couchdb = Chef::CouchDB.new + @run_state = { :template_cache => Hash.new, :seen_recipes => Hash.new @@ -281,53 +283,17 @@ class Chef @run_list.detect { |r| r == item } ? true : false end - # Turns the node into an object that we can index. I apologize up front for the - # super confusion that is the recursive index_flatten hash, which comes up next. - # Faith, young one, faith. - # - # === Returns - # index_hash<Hash>:: A flattened hash of all the nodes attributes, suitable for indexing. - def to_index - index_hash = { - "index_name" => "node", - "id" => "node_#{@name}", - "name" => @name, - } - @attribute.each do |key, value| - if value.kind_of?(Hash) || value.kind_of?(Mash) - index_flatten_hash(key, value).each do |to_index| - to_index.each do |nk, nv| - index_hash[nk] = nv - end - end - else - index_hash[key] = value - end - end - index_hash["recipe"] = @run_list.recipes if @run_list.recipes.length > 0 + # Transform the node to a Hash + def to_hash + index_hash = @attribute + index_hash["chef_type"] = "node" + index_hash["name"] = @name + index_hash["recipes"] = @run_list.recipes if @run_list.recipes.length > 0 index_hash["roles"] = @run_list.roles if @run_list.roles.length > 0 index_hash["run_list"] = @run_list.run_list if @run_list.run_list.length > 0 index_hash end - # Ah, song of my heart, index_flatten_hash. This method flattens a hash in preparation - # for indexing, by appending the name of it's parent to a current key with an _. Hence, - # node[:bar][:baz] = 'monkey' becomes bar_baz:monkey. - # - # === Returns - # results<Array>:: An array of hashes with one element. - def index_flatten_hash(parent_name, hash) - results = Array.new - hash.each do |k, v| - if v.kind_of?(Hash) || v.kind_of?(Mash) - results << index_flatten_hash("#{parent_name}_#{k}", v) - else - results << { "#{parent_name}_#{k}", v } - end - end - results.flatten - end - # Serialize this object as a hash def to_json(*a) result = { @@ -360,47 +326,103 @@ class Chef o["recipes"].each { |r| node.recipes << r } end node.couchdb_rev = o["_rev"] if o.has_key?("_rev") + node.couchdb_id = o["_id"] if o.has_key?("_id") node end # List all the Chef::Node objects in the CouchDB. If inflate is set to true, you will get # the full list of all Nodes, fully inflated. - def self.list(inflate=false) - rs = Chef::CouchDB.new.list("nodes", inflate) + def self.cdb_list(inflate=false) + couchdb = Chef::CouchDB.new + rs = couchdb.list("nodes", inflate) if inflate rs["rows"].collect { |r| r["value"] } else rs["rows"].collect { |r| r["key"] } end end + + def self.list(inflate=false) + r = Chef::REST.new(Chef::Config[:chef_server_url]) + if inflate + response = Hash.new + Chef::Search::Query.new.search(:node) do |n| + response[n.name] = n + end + response + else + r.get_rest("nodes") + end + end # Load a node by name from CouchDB + def self.cdb_load(name) + couchdb = Chef::CouchDB.new + couchdb.load("node", name) + end + + # Load a node by name def self.load(name) - Chef::CouchDB.new.load("node", name) + r = Chef::REST.new(Chef::Config[:chef_server_url]) + r.get_rest("nodes/#{escape_node_id(name)}") end # Remove this node from the CouchDB - def destroy - Chef::Queue.send_msg(:queue, :remove, self) + def cdb_destroy @couchdb.delete("node", @name, @couchdb_rev) end + + # Remove this node via the REST API + def destroy + r = Chef::REST.new(Chef::Config[:chef_server_url]) + r.delete_rest("nodes/#{Chef::Node.escape_node_id(@name)}") + end # Save this node to the CouchDB - def save - Chef::Queue.send_msg(:queue, :index, self) + def cdb_save results = @couchdb.store("node", @name, self) @couchdb_rev = results["rev"] end + + # Save this node via the REST API + def save + r = Chef::REST.new(Chef::Config[:chef_server_url]) + begin + r.put_rest("nodes/#{Chef::Node.escape_node_id(@name)}", self) + rescue Net::HTTPServerException => e + if e.response.code == "404" + r.post_rest("nodes", self) + else + raise e + end + end + self + end + # Create the node via the REST API + def create + r = Chef::REST.new(Chef::Config[:chef_server_url]) + r.post_rest("nodes", self) + self + end + # Set up our CouchDB design document def self.create_design_document - Chef::CouchDB.new.create_design_document("nodes", DESIGN_DOCUMENT) + couchdb = Chef::CouchDB.new + couchdb.create_design_document("nodes", DESIGN_DOCUMENT) end # As a string def to_s "node[#{@name}]" end + + private + + def self.escape_node_id(arg=nil) + arg.gsub(/\./, '_') + end + end end chef/lib/chef/node.rb @@ -178,4 +178,4 @@ class Chef end end -end \ No newline at end of file +end chef/lib/chef/openid_registration.rb @@ -142,7 +142,6 @@ class Chef if pmap.has_key?(rtkey) pmap[rtkey] else - Chef::Log.error("#{rtkey.inspect} #{pmap.inspect}") raise( ArgumentError, "Cannot find a provider for #{resource_type} on #{platform} version #{version}" chef/lib/chef/platform.rb @@ -129,7 +129,6 @@ class Chef status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr| crontab.each { |line| stdin.puts "#{line}" } - stdin.close rescue nil end Chef::Log.info("Updated cron '#{@new_resource.name}'") @new_resource.updated = true @@ -144,7 +143,6 @@ class Chef status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr| crontab.each { |line| stdin.puts "#{line}" } - stdin.close rescue nil end Chef::Log.info("Added cron '#{@new_resource.name}'") @new_resource.updated = true @@ -175,7 +173,6 @@ class Chef status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr| crontab.each { |line| stdin.puts "#{line}" } - stdin.close rescue nil end Chef::Log.debug("Deleted cron '#{@new_resource.name}'") @new_resource.updated = true chef/lib/chef/provider/cron.rb @@ -61,9 +61,15 @@ class Chef def action_deploy if all_releases.include?(release_path) - Chef::Log.info("Already deployed app at #{release_path}, skipping. Use action :force_deploy to force.") + if all_releases[-1] == release_path + Chef::Log.debug("Already deployed app at #{release_path}, and it is the latest revision. Use action :force_deploy to re-deploy this revision.") + else + Chef::Log.info("Already deployed app at #{release_path}. Rolling back to it - use action :force_deploy to re-checkout this revision.") + action_rollback + end else deploy + @new_resource.updated = true end end @@ -73,18 +79,31 @@ class Chef FileUtils.rm_rf(release_path) end deploy + @new_resource.updated = true end def action_rollback - @release_path = all_releases[-2] - raise RuntimeError, "There is no release to rollback to!" unless @release_path - release_to_nuke = all_releases.last + if release_path + rp_index = all_releases.index(release_path) + raise RuntimeError, "There is no release to rollback to!" unless rp_index + rp_index += 1 + releases_to_nuke = all_releases[rp_index..-1] + else + @release_path = all_releases[-2] + raise RuntimeError, "There is no release to rollback to!" unless @release_path + releases_to_nuke = [ all_releases.last ] + end + Chef::Log.info "rolling back to previous release: #{release_path}" symlink - Chef::Log.info "removing last release: #{release_to_nuke}" - FileUtils.rm_rf release_to_nuke Chef::Log.info "restarting with previous release" restart + releases_to_nuke.each do |i| + Chef::Log.info "Removing release: #{i}" + FileUtils.rm_rf i + release_deleted(i) + end + @new_resource.updated = true end def deploy @@ -167,7 +186,7 @@ class Chef end def all_releases - Dir.glob(@new_resource.deploy_to + "/releases/*") + Dir.glob(@new_resource.deploy_to + "/releases/*").sort end def update_cached_repo chef/lib/chef/provider/deploy.rb @@ -39,11 +39,13 @@ class Chef clone checkout enable_submodules + @new_resource.updated = true end def action_export action_checkout FileUtils.rm_rf(::File.join(@new_resource.destination,".git")) + @new_resource.updated = true end def action_sync @@ -53,6 +55,8 @@ class Chef sync enable_submodules end + + @new_resource.updated = true end def find_current_revision @@ -191,4 +195,4 @@ class Chef end end -end \ No newline at end of file +end chef/lib/chef/provider/git.rb @@ -25,7 +25,7 @@ class Chef attr_accessor :rest def load_current_resource - @rest = Chef::REST.new(@new_resource.url) + @rest = Chef::REST.new(@new_resource.url, nil, nil) end # Send a GET request to @new_resource.url, with ?message=@new_resource.message @@ -34,6 +34,7 @@ class Chef body = @rest.run_request( :GET, @rest.create_url("#{@new_resource.url}?message=#{message}"), + {}, false, 10, false @@ -49,6 +50,7 @@ class Chef body = @rest.run_request( :PUT, @rest.create_url("#{@new_resource.url}"), + {}, message, 10, false @@ -64,6 +66,7 @@ class Chef body = @rest.run_request( :POST, @rest.create_url("#{@new_resource.url}"), + {}, message, 10, false @@ -78,6 +81,7 @@ class Chef body = @rest.run_request( :DELETE, @rest.create_url("#{@new_resource.url}"), + {}, false, 10, false @@ -99,4 +103,4 @@ class Chef end end -end \ No newline at end of file +end chef/lib/chef/provider/http_request.rb @@ -38,7 +38,7 @@ class Chef if( ::File.exists?(catdir) ) Dir.entries(catdir).each do |entry| - if(entry =~ /^#{Regexp.escape(pkg)}\-(\d[\.\d]*((_(alpha|beta|pre|rc|p)\d*)*)?)/) + if(entry =~ /^#{Regexp.escape(pkg)}\-(\d[\.\d]*((_(alpha|beta|pre|rc|p)\d*)*)?(-r\d+)?)/) @current_resource.version($1) Chef::Log.debug("Got current version #{$1}") break chef/lib/chef/provider/package/portage.rb @@ -34,6 +34,8 @@ import yum from yum import Errors +PIDFILE='/var/run/yum.pid' + # Seconds to wait for exclusive access to yum lock_timeout = 10 @@ -54,7 +56,7 @@ try: countdown = lock_timeout while True: try: - y.doLock() + y.doLock(PIDFILE) except Errors.LockError, e: time.sleep(1) countdown -= 1 @@ -80,7 +82,7 @@ try: # Ensure we clear the lock. finally: try: - y.doUnlock() + y.doUnlock(PIDFILE) # Keep Unlock from raising a second exception as it does with a yum.conf # config error. except Errors.YumBaseError: chef/lib/chef/provider/package/yum-dump.py @@ -102,7 +102,7 @@ class Chef begin uri = URI.parse(source) if uri.absolute - r = Chef::REST.new(source) + r = Chef::REST.new(source, nil, nil) Chef::Log.debug("Downloading from absolute URI: #{source}") r.get_rest(source, true).open end chef/lib/chef/provider/remote_file.rb @@ -70,7 +70,6 @@ class Chef end status = popen4(@node[:command][:ps]) do |pid, stdin, stdout, stderr| - stdin.close rescue nil r = Regexp.new(@new_resource.pattern) Chef::Log.debug("#{@new_resource}: attempting to match #{@new_resource.pattern} (#{r}) against process table") stdout.each_line do |line| chef/lib/chef/provider/service/freebsd.rb @@ -55,7 +55,6 @@ class Chef raise Chef::Exceptions::Service, "#{@new_resource}: could not determine how to inspect the process table, please set this nodes 'command.ps' attribute" end status = popen4(@node[:command][:ps]) do |pid, stdin, stdout, stderr| - stdin.close rescue nil r = Regexp.new(@new_resource.pattern) Chef::Log.warn "#{@new_resource}: attempting to match '#{@new_resource.pattern}' (#{r}) against process list" stdout.each_line do |line| chef/lib/chef/provider/service/simple.rb @@ -37,10 +37,12 @@ class Chef def action_checkout run_command(run_options(:command => checkout_command)) + @new_resource.updated = true end def action_export run_command(run_options(:command => export_command)) + @new_resource.updated = true end def action_sync @@ -49,6 +51,7 @@ class Chef else run_command(run_options(:command => sync_command)) end + @new_resource.updated = true end def sync_command chef/lib/chef/provider/subversion.rb @@ -34,7 +34,6 @@ class Chef include Chef::Mixin::FindPreferredFile def action_create - Chef::Log.debug(@node.run_state.inspect) raw_template_file = nil cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name chef/lib/chef/provider/template.rb @@ -25,7 +25,6 @@ require 'chef/mixin/recipe_definition_dsl_core' require 'chef/resource_collection' require 'chef/cookbook_loader' require 'chef/rest' -require 'chef/search/result' class Chef class Recipe @@ -76,21 +75,6 @@ class Chef @collection.resources(*args) end - def search(type, query, attributes=[], &block) - Chef::Log.debug("Searching #{type} index with #{query}") - r = Chef::REST.new(Chef::Config[:search_url]) - - results = r.get_rest("search/#{type}?q=#{query}&a=#{attributes.join(',')}") - Chef::Log.debug("Searching #{type} index with #{query} returned #{results.length} entries") - if block - results.each do |sr| - block.call(sr) - end - else - results - end - end - # Sets a tag, or list of tags, for this node. Syntactic sugar for # @node[:tags]. # chef/lib/chef/recipe.rb @@ -69,10 +69,9 @@ class Chef @remote = "origin" @enable_submodules = false @shallow_clone = false - @force_deploy = false @scm_provider = Chef::Provider::Git @provider = Chef::Provider::Deploy::Timestamped - @allowed_actions.push(:deploy, :rollback) + @allowed_actions.push(:force_deploy, :deploy, :rollback) end # where the checked out/cloned code goes @@ -244,15 +243,6 @@ class Chef ) end - # Shall we run the deploy even if the code has not changed? - def force_deploy(arg=nil) - set_or_return( - :force_deploy, - arg, - :kind_of => [ TrueClass, FalseClass ] - ) - end - def scm_provider(arg=nil) set_or_return( :scm_provider, @@ -357,4 +347,4 @@ class Chef end end -end \ No newline at end of file +end chef/lib/chef/resource/deploy.rb @@ -1,7 +1,8 @@ # # Author:: Adam Jacob (<adam@opscode.com>) # Author:: Thom May (<thom@clearairturbulence.org>) -# Copyright:: Copyright (c) 2008 Opscode, Inc. +# Author:: Nuo Yan (<nuo@opscode.com>) +# Copyright:: Copyright (c) 2009 Opscode, Inc. # License:: Apache License, Version 2.0 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -24,6 +25,9 @@ require 'uri' require 'json' require 'tempfile' require 'singleton' +require 'mixlib/authentication/signedheaderauth' + +include Mixlib::Authentication::SignedHeaderAuth class Chef class REST @@ -32,47 +36,57 @@ class Chef include Singleton end - attr_accessor :url, :cookies + attr_accessor :url, :cookies, :signing_key - def initialize(url) + def initialize(url, client_name=Chef::Config[:node_name], signing_key=Chef::Config[:client_key]) @url = url @cookies = CookieJar.instance + @client_name = client_name + if signing_key + @signing_key = load_signing_key(signing_key) + else + @signing_key = nil + end + end + + def load_signing_key(key) + if File.exists?(key) && File.readable?(key) + IO.read(key) + else + raise Chef::Exceptions::PrivateKeyMissing, "I cannot find #{key}, which you told me to use to sign requests!" + end end - # Register for an OpenID - def register(user, pass, validation_token=nil) - Chef::Log.debug("Registering #{user} for an openid") - registration = nil + # Register the client + def register(name=Chef::Config[:node_name], destination=Chef::Config[:client_key]) + + if File.exists?(destination) + raise Chef::Exceptions::CannotWritePrivateKey, "I cannot write your private key to #{destination} - check permissions?" unless File.writable?(destination) + end + + # First, try and create a new registration begin - registration = get_rest("registrations/#{user}") - rescue Net::HTTPServerException => e - unless e.message =~ /^404/ - raise e - end + Chef::Log.info("Registering API Client #{name}") + response = post_rest("clients", {:name => name}) + rescue Net::HTTPServerException + # If that fails, go ahead and try and update it + response = put_rest("clients/#{name}", { :name => name, :private_key => true }) end - unless registration - post_rest( - "registrations", - { - :id => user, - :password => pass, - :validation_token => validation_token - } - ) + + Chef::Log.debug("Registration response: #{response.inspect}") + + raise Chef::Exceptions::CannotWritePrivateKey, "The response from the server did not include a private key!" unless response.has_key?("private_key") + + begin + # Write out the private key + file = File.open(destination, "w") + file.print(response["private_key"]) + file.close + rescue + raise Chef::Exceptions::CannotWritePrivateKey, "I cannot write your private key to #{destination}" end - end - - # Authenticate - def authenticate(user, pass) - Chef::Log.debug("Authenticating #{user} via openid") - response = post_rest('openid/consumer/start', { - "openid_identifier" => "#{Chef::Config[:openid_url]}/openid/server/node/#{user}", - "submit" => "Verify" - }) - post_rest( - "#{Chef::Config[:openid_url]}#{response["action"]}", - { "password" => pass } - ) + + true end # Send an HTTP GET request to the path @@ -81,23 +95,23 @@ class Chef # path:: The path to GET # raw:: Whether you want the raw body returned, or JSON inflated. Defaults # to JSON inflated. - def get_rest(path, raw=false) - run_request(:GET, create_url(path), false, 10, raw) + def get_rest(path, raw=false, headers={}) + run_request(:GET, create_url(path), headers, false, 10, raw) end # Send an HTTP DELETE request to the path - def delete_rest(path) - run_request(:DELETE, create_url(path)) + def delete_rest(path, headers={}) + run_request(:DELETE, create_url(path), headers) end # Send an HTTP POST request to the path - def post_rest(path, json) - run_request(:POST, create_url(path), json) + def post_rest(path, json, headers={}) + run_request(:POST, create_url(path), headers, json) end # Send an HTTP PUT request to the path - def put_rest(path, json) - run_request(:PUT, create_url(path), json) + def put_rest(path, json, headers={}) + run_request(:PUT, create_url(path), headers, json) end def create_url(path) @@ -108,6 +122,18 @@ class Chef end end + def sign_request(http_method, private_key, user_id, body = "", host="localhost") + #body = "" if body == false + timestamp = Time.now.utc.iso8601 + sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object( + :http_method=>http_method, + :body=>body, + :user_id=>user_id, + :timestamp=>timestamp) + signed = sign_obj.sign(private_key).merge({:host => host}) + signed.inject({}){|memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1];memo} + end + # Actually run an HTTP request. First argument is the HTTP method, # which should be one of :GET, :PUT, :POST or :DELETE. Next is the # URL, then an object to include in the body (which will be converted with @@ -117,7 +143,8 @@ class Chef # the helper methods (get_rest, post_rest, etc.) # # Will return the body of the response on success. - def run_request(method, url, data=false, limit=10, raw=false) + def run_request(method, url, headers={}, data=false, limit=10, raw=false) + http_retry_delay = Chef::Config[:http_retry_delay] http_retry_count = Chef::Config[:http_retry_count] @@ -129,21 +156,35 @@ class Chef if Chef::Config[:ssl_verify_mode] == :verify_none http.verify_mode = OpenSSL::SSL::VERIFY_NONE end - if File.exists?(Chef::Config[:ssl_client_cert]) + if Chef::Config[:ssl_client_cert] && File.exists?(Chef::Config[:ssl_client_cert]) http.cert = OpenSSL::X509::Certificate.new(File.read(Chef::Config[:ssl_client_cert])) http.key = OpenSSL::PKey::RSA.new(File.read(Chef::Config[:ssl_client_key])) end end + http.read_timeout = Chef::Config[:rest_timeout] - headers = Hash.new + unless raw - headers = { + headers = headers.merge({ 'Accept' => "application/json", - } + }) end + if @cookies.has_key?("#{url.host}:#{url.port}") headers['Cookie'] = @cookies["#{url.host}:#{url.port}"] end + + json_body = data ? data.to_json : nil + + if @signing_key + Chef::Log.debug("Signing the request as #{@client_name}") + if json_body + headers.merge!(sign_request(method, OpenSSL::PKey::RSA.new(@signing_key), @client_name, json_body, "#{url.host}:#{url.port}")) + else + headers.merge!(sign_request(method, OpenSSL::PKey::RSA.new(@signing_key), @client_name, "", "#{url.host}:#{url.port}")) + end + end + req = nil case method when :GET @@ -152,12 +193,16 @@ class Chef req = Net::HTTP::Get.new(req_path, headers) when :POST headers["Content-Type"] = 'application/json' if data - req = Net::HTTP::Post.new(url.path, headers) - req.body = data.to_json if data + req_path = "#{url.path}" + req_path << "?#{url.query}" if url.query + req = Net::HTTP::Post.new(req_path, headers) + req.body = json_body if json_body when :PUT headers["Content-Type"] = 'application/json' if data - req = Net::HTTP::Put.new(url.path, headers) - req.body = data.to_json if data + req_path = "#{url.path}" + req_path << "?#{url.query}" if url.query + req = Net::HTTP::Put.new(req_path, headers) + req.body = json_body if json_body when :DELETE req_path = "#{url.path}" req_path << "?#{url.query}" if url.query @@ -165,11 +210,12 @@ class Chef else raise ArgumentError, "You must provide :GET, :PUT, :POST or :DELETE as the method" end + + Chef::Log.debug("Sending HTTP Request via #{req.method} to #{url.host}:#{url.port}/#{req.path}") # Optionally handle HTTP Basic Authentication req.basic_auth(url.user, url.password) if url.user - Chef::Log.debug("Sending HTTP Request via #{req.method} to #{req.path}") res = nil tf = nil http_retries = 1 @@ -199,7 +245,8 @@ class Chef end response end - rescue Errno::ECONNREFUSED + + rescue Errno::ECONNREFUSED => e Chef::Log.error("Connection refused connecting to #{url.host}:#{url.port} for #{req.path} #{http_retries}/#{http_retry_count}") sleep(http_retry_delay) retry if (http_retries += 1) < http_retry_count @@ -216,7 +263,8 @@ class Chef @cookies["#{url.host}:#{url.port}"] = res['set-cookie'] end if res['content-type'] =~ /json/ - JSON.parse(res.body) + response_body = res.body.chomp + JSON.parse(response_body) else if raw tf @@ -228,11 +276,11 @@ class Chef if res['set-cookie'] @cookies["#{url.host}:#{url.port}"] = res['set-cookie'] end - run_request(:GET, create_url(res['location']), false, limit - 1, raw) + run_request(:GET, create_url(res['location']), {}, false, limit - 1, raw) else res.error! end end - + end end chef/lib/chef/rest.rb @@ -1,5 +1,6 @@ # # Author:: Adam Jacob (<adam@opscode.com>) +# Author:: Nuo Yan (<nuo@opscode.com>) # Copyright:: Copyright (c) 2008 Opscode, Inc. # License:: Apache License, Version 2.0 # @@ -30,7 +31,7 @@ class Chef include Chef::Mixin::ParamsValidate DESIGN_DOCUMENT = { - "version" => 3, + "version" => 6, "language" => "javascript", "views" => { "all" => { @@ -50,21 +51,22 @@ class Chef } } EOJS - }, - }, + } + } } - attr_accessor :couchdb_rev + attr_accessor :couchdb_rev, :couchdb_id # Create a new Chef::Role object. - def initialize() + def initialize @name = '' @description = '' @default_attributes = Mash.new @override_attributes = Mash.new @recipes = Array.new @couchdb_rev = nil - @couchdb = Chef::CouchDB.new + @couchdb_id = nil + @couchdb = Chef::CouchDB.new end def name(arg=nil) @@ -139,27 +141,50 @@ class Chef role.override_attributes(o["override_attributes"]) role.recipes(o["recipes"]) role.couchdb_rev = o["_rev"] if o.has_key?("_rev") + role.couchdb_id = o["_id"] if o.has_key?("_id") role end # List all the Chef::Role objects in the CouchDB. If inflate is set to true, you will get # the full list of all Roles, fully inflated. - def self.list(inflate=false) - rs = Chef::CouchDB.new.list("roles", inflate) + def self.cdb_list(inflate=false) + couchdb = Chef::CouchDB.new + rs = couchdb.list("roles", inflate) if inflate rs["rows"].collect { |r| r["value"] } else rs["rows"].collect { |r| r["key"] } end end + + # Get the list of all roles from the API. + def self.list(inflate=false) + r = Chef::REST.new(Chef::Config[:chef_server_url]) + if inflate + response = Hash.new + Chef::Search::Query.new.search(:role) do |n| + response[n.name] = n + end + response + else + r.get_rest("roles") + end + end # Load a role by name from CouchDB + def self.cdb_load(name) + couchdb = Chef::CouchDB.new + couchdb.load("role", name) + end + + # Load a role by name from the API def self.load(name) - Chef::CouchDB.new.load("role", name) + r = Chef::REST.new(Chef::Config[:chef_server_url]) + r.get_rest("roles/#{name}") end # Remove this role from the CouchDB - def destroy + def cdb_destroy @couchdb.delete("role", @name, @couchdb_rev) if Chef::Config[:couchdb_version] == 0.9 @@ -167,26 +192,62 @@ class Chef rs["rows"].each do |row| node = row["doc"] node.run_list.remove("role[#{@name}]") - node.save + node.cdb_save end else - Chef::Node.list.each do |node| - n = Chef::Node.load(node) + Chef::Node.cdb_list.each do |node| + n = Chef::Node.cdb_load(node) n.run_list.remove("role[#{@name}]") - n.save + n.cdb_save end end end + # Remove this role via the REST API + def destroy + r = Chef::REST.new(Chef::Config[:chef_server_url]) + r.delete_rest("roles/#{@name}") + + Chef::Node.list.each do |node| + n = Chef::Node.load(node[0]) + n.run_list.remove("role[#{@name}]") + n.save + end + + end + # Save this role to the CouchDB - def save + def cdb_save results = @couchdb.store("role", @name, self) @couchdb_rev = results["rev"] end + # Save this role via the REST API + def save + r = Chef::REST.new(Chef::Config[:chef_server_url]) + begin + r.put_rest("roles/#{@name}", self) + rescue Net::HTTPServerException => e + if e.response.code == "404" + r.post_rest("roles", self) + else + raise e + end + end + self + end + + # Create the role via the REST API + def create + r = Chef::REST.new(Chef::Config[:chef_server_url]) + r.post_rest("roles", self) + self + end + # Set up our CouchDB design document def self.create_design_document - Chef::CouchDB.new.create_design_document("roles", DESIGN_DOCUMENT) + couchdb = Chef::CouchDB.new + couchdb.create_design_document("roles", DESIGN_DOCUMENT) end # As a string @@ -217,13 +278,13 @@ class Chef Chef::Log.warn("Loading #{short_name}") r = Chef::Role.from_disk(short_name, "json") begin - couch_role = Chef::Role.load(short_name) + couch_role = Chef::Role.cdb_load(short_name) r.couchdb_rev = couch_role.couchdb_rev Chef::Log.debug("Replacing role #{short_name} with data from #{role_file}") - rescue Net::HTTPServerException + rescue Chef::Exceptions::CouchDBNotFound Chef::Log.debug("Creating role #{short_name} with data from #{role_file}") end - r.save + r.cdb_save end end chef/lib/chef/role.rb @@ -112,6 +112,7 @@ class Chef end def expand(from='server') + couchdb = Chef::CouchDB.new recipes = Array.new default_attrs = Mash.new override_attrs = Mash.new @@ -132,7 +133,7 @@ class Chef role = r.get_rest("roles/#{name}") elsif from == 'couchdb' # Load the role from couchdb - role = Chef::Role.load(name) + role = Chef::Role.cdb_load(name) end role.recipes.each { |r| recipes << r unless recipes.include?(r) } default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, role.default_attributes) chef/lib/chef/run_list.rb @@ -111,7 +111,7 @@ class Chef run_action(resource, ra) end rescue => e - Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace}") + Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace.join("\n")}") raise e unless resource.ignore_failure end end chef/lib/chef/runner.rb @@ -185,6 +185,8 @@ def create_cookbook(dir) sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "recipes")}" sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "definitions")}" sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "libraries")}" + sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "resources")}" + sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "providers")}" sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "files", "default")}" sh "mkdir -p #{File.join(dir, ENV["COOKBOOK"], "templates", "default")}" unless File.exists?(File.join(dir, ENV["COOKBOOK"], "recipes", "default.rb")) @@ -343,3 +345,63 @@ task :roles do end end +desc "Upload all cookbooks" +task :upload_cookbooks => [ :metadata ] +task :upload_cookbooks do + Chef::Config[:cookbook_path] = [ File.join(TOPDIR, 'cookbooks'), File.join(TOPDIR, 'site-cookbooks') ] + cl = Chef::CookbookLoader.new + cl.each do |cookbook| + cook_meta = Chef::Cookbook::Metadata.new(cookbook) + upload_single_cookbook(cookbook.name.to_s, cook_meta.version) + puts "* Uploaded #{cookbook.name.to_s}" + end +end + +desc "Upload a single cookbook" +task :upload_cookbook => [ :metadata ] +task :upload_cookbook, :cookbook do |t, args| + upload_single_cookbook(args.cookbook) + puts "* Uploaded #{args.cookbook}" +end + +def upload_single_cookbook(cookbook_name, version=nil) + require 'chef/streaming_cookbook_uploader' + Chef::Log.level(:error) + Mixlib::Authentication::Log.logger = Chef::Log.logger + raise ArgumentError, "OPSCODE_KEY must be set to your API Key" unless ENV.has_key?("OPSCODE_KEY") + raise ArgumentError, "OPSCODE_USER must be set to your Username" unless ENV.has_key?("OPSCODE_USER") + + Chef::Config.from_file("/etc/chef/client.rb") + + tarball_name = "#{cookbook_name}.tar.gz" + temp_dir = File.join(Dir.tmpdir, "chef-upload-cookbooks") + temp_cookbook_dir = File.join(temp_dir, cookbook_name) + FileUtils.mkdir(temp_dir) + FileUtils.mkdir(temp_cookbook_dir) + + child_folders = [ "cookbooks/#{cookbook_name}", "site-cookbooks/#{cookbook_name}" ] + child_folders.each do |folder| + file_path = File.join(TOPDIR, folder, ".") + FileUtils.cp_r(file_path, temp_cookbook_dir) if File.directory?(file_path) + end + + system("tar", "-C", temp_dir, "-czf", File.join(temp_dir, tarball_name), "./#{cookbook_name}") + + r = Chef::REST.new(Chef::Config[:chef_server_url], ENV['OPSCODE_USER'], ENV['OPSCODE_KEY']) + begin + cb = r.get_rest("cookbooks/#{cookbook_name}") + cookbook_uploaded = true + rescue Net::HTTPServerException + cookbook_uploaded = false + end + puts "* Uploading #{cookbook_name} (#{cookbook_uploaded ? 'new version' : 'first time'})" + if cookbook_uploaded + Chef::StreamingCookbookUploader.put("#{Chef::Config[:chef_server_url]}/cookbooks/#{cookbook_name}/_content", ENV["OPSCODE_USER"], ENV["OPSCODE_KEY"], {:file => File.new(File.join(temp_dir, tarball_name)), :name => cookbook_name}) + else + Chef::StreamingCookbookUploader.post("#{Chef::Config[:chef_server_url]}/cookbooks", ENV["OPSCODE_USER"], ENV["OPSCODE_KEY"], {:file => File.new(File.join(temp_dir, tarball_name)), :name => cookbook_name}) + end + + #delete temp files (e.g. /tmp/cookbooks and /tmp/cookbooks.tgz) + FileUtils.rm_rf temp_dir +end + chef/lib/chef/tasks/chef_repo.rake @@ -30,18 +30,9 @@ describe Chef::Client, "run" do to_stub = [ :build_node, :register, - :authenticate, - :sync_library_files, - :sync_provider_files, - :sync_resource_files, - :sync_attribute_files, - :sync_definitions, - :sync_recipes, + :sync_cookbooks, :save_node, - :save_node, - :run_ohai, - :safe_name, - :node_name + :converge ] to_stub.each do |method| @client.stub!(method).and_return(true) @@ -63,43 +54,13 @@ describe Chef::Client, "run" do @client.run end - it "should register for an openid" do + it "should register for a client" do @client.should_receive(:register).and_return(true) @client.run end - it "should authenticate with the server" do - @client.should_receive(:authenticate).and_return(true) - @client.run - end - - it "should synchronize definitions from the server" do - @client.should_receive(:sync_definitions).and_return(true) - @client.run - end - - it "should synchronize recipes from the server" do - @client.should_receive(:sync_recipes).and_return(true) - @client.run - end - - it "should synchronize and load library files from the server" do - @client.should_receive(:sync_library_files).and_return(true) - @client.run - end - - it "should synchronize and load attribute files from the server" do - @client.should_receive(:sync_attribute_files).and_return(true) - @client.run - end - - it "should synchronize providers from the server" do - @client.should_receive(:sync_provider_files).and_return(true) - @client.run - end - - it "should synchronize resources from the server" do - @client.should_receive(:sync_resource_files).and_return(true) + it "should synchronize the cookbooks from the server" do + @client.should_receive(:sync_cookbooks).and_return(true) @client.run end @@ -113,11 +74,6 @@ describe Chef::Client, "run" do @client.run end - it "should set the cookbook_path" do - Chef::Config.should_receive('[]').with(:file_cache_path). - and_return('/var/chef/cache/cookbooks') - @client.run - end end describe Chef::Client, "run_solo" do @@ -166,6 +122,7 @@ describe Chef::Client, "build_node" do Chef::REST.stub!(:new).and_return(@mock_rest) @client = Chef::Client.new Chef::Platform.stub!(:find_platform_and_version).and_return(["FooOS", "1.3.3.7"]) + Chef::Config[:node_name] = nil end it "should set the name equal to the FQDN" do @@ -225,35 +182,34 @@ describe Chef::Client, "register" do before do @mock_rest = mock("Chef::REST", :null_object => true) @mock_rest.stub!(:get_rest).and_return(true) + @mock_rest.stub!(:register).and_return(true) Chef::REST.stub!(:new).and_return(@mock_rest) @chef_client = Chef::Client.new @chef_client.safe_name = "testnode" + @chef_client.node_name = "testnode" @chef_client.stub!(:determine_node_name).and_return(true) - @chef_client.stub!(:create_registration).and_return(true) - Chef::Application.stub!(:fatal!).and_return(true) - Chef::FileCache.stub!(:create_cache_path).and_return("/tmp") - Chef::FileCache.stub!(:load).and_return("/tmp/testnode") - end - - it "should log an appropriate debug message regarding registering an openid" do - Chef::Log.should_receive(:debug).with("Registering testnode for an openid").and_return(true) - @chef_client.register + File.stub!(:exists?).and_return(false) end + + describe "when the validation key is present" do + before(:each) do + File.stub!(:exists?).with(Chef::Config[:validation_key]).and_return(true) + end - it "should fetch the registration based on safe_name from the chef server" do - @mock_rest.should_receive(:get_rest).with("registrations/testnode").and_return(true) - @chef_client.register - end + it "should sign requests with the validation key" do + Chef::REST.should_receive(:new).with(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).and_return(@mock_rest) + @chef_client.register + end - it "should load the secret from disk" do - Chef::FileCache.should_receive(:load).with(File.join("registration", "testnode")).and_return("/tmp/testnode") - @chef_client.register + it "should register for a new key-pair" do + @mock_rest.should_receive(:register).with("testnode", Chef::Config[:client_key]) + @chef_client.register + end end - it "should cause chef to die fatally if the filecache cannot find the registration" do - Chef::FileCache.stub!(:load).with(File.join("registration", "testnode")).and_raise(Chef::Exceptions::FileNotFound) - Chef::Application.should_receive(:fatal!).with(/^.*$/, 3).and_return(true) - @chef_client.register + it "should setup the rest client to use the client key-pair" do + Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(@mock_rest) + @chef_client.register end end @@ -273,3 +229,4 @@ describe Chef::Client, "run_ohai" do @chef_client.run_ohai end end + chef/spec/unit/client_spec.rb @@ -18,236 +18,245 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper")) -describe Chef::CouchDB, "new" do - before do +describe Chef::CouchDB do + before(:each) do @mock_rest = mock("Chef::REST", :null_object => true) @mock_rest.stub!(:run_request).and_return({"couchdb" => "Welcome", "version" =>"0.9.0"}) @mock_rest.stub!(:url).and_return("http://localhost:5984") Chef::REST.stub!(:new).and_return(@mock_rest) - end - - it "should create a new Chef::REST object from the default url" do - Chef::Config[:couchdb_url] = "http://monkey" - Chef::REST.should_receive(:new).with("http://monkey") - Chef::CouchDB.new + @couchdb = Chef::CouchDB.new + Chef::Nanite.stub!(:push).and_return(true) + Chef::Nanite.stub!(:in_event).and_return(true) + Chef::Nanite.stub!(:start_mapper).and_return(true) end - it "should create a new Chef::REST object from a provided url" do - Chef::REST.should_receive(:new).with("http://monkeypants") - Chef::CouchDB.new("http://monkeypants") - end -end + describe "new" do + it "should create a new Chef::REST object from the default url" do + old_url = Chef::Config[:couchdb_url] + Chef::Config[:couchdb_url] = "http://monkey" + Chef::REST.should_receive(:new).with("http://monkey", nil, nil) + Chef::CouchDB.new + Chef::Config[:couchdb_url] = old_url + end -describe Chef::CouchDB, "create_db" do - before(:each) do - @mock_rest = mock("Chef::REST", :null_object => true) - @mock_rest.stub!(:get_rest).and_return([ "chef" ]) - @mock_rest.stub!(:put_rest).and_return(true) - Chef::REST.stub!(:new).and_return(@mock_rest) - end - - def do_create_db - couch = Chef::CouchDB.new - couch.create_db - end - - it "should get a list of current databases" do - @mock_rest.should_receive(:get_rest).and_return(["chef"]) - do_create_db - end - - it "should create the chef database if it does not exist" do - @mock_rest.stub!(:get_rest).and_return([]) - @mock_rest.should_receive(:put_rest).with("chef", {}).and_return(true) - do_create_db + it "should create a new Chef::REST object from a provided url" do + Chef::REST.should_receive(:new).with("http://monkeypants", nil, nil) + Chef::CouchDB.new("http://monkeypants") + end end - - it "should not create the chef database if it does exist" do - @mock_rest.stub!(:get_rest).and_return(["chef"]) - @mock_rest.should_not_receive(:put_rest) - do_create_db - end - - it "should return 'chef'" do - do_create_db.should eql("chef") + + describe "create_db" do + before(:each) do + @couchdb.stub!(:create_design_document).and_return(true) + end + + it "should get a list of current databases" do + @mock_rest.should_receive(:get_rest).and_return(["chef"]) + @couchdb.create_db + end + + it "should create the chef database if it does not exist" do + @mock_rest.stub!(:get_rest).and_return([]) + @mock_rest.should_receive(:put_rest).with("chef", {}).and_return(true) + @couchdb.create_db + end + + it "should not create the chef database if it does exist" do + @mock_rest.stub!(:get_rest).and_return(["chef"]) + @mock_rest.should_not_receive(:put_rest) + @couchdb.create_db + end + + it "should return 'chef'" do + @couchdb.create_db.should eql("chef") + end end -end -describe Chef::CouchDB, "create_design_document" do - before(:each) do - @mock_rest = mock("Chef::REST", :null_object => true) - @mock_design = { - "version" => 1, - "_rev" => 1 - } - @mock_data = { - "version" => 1, - "language" => "javascript", - "views" => { - "all" => { - "map" => <<-EOJS - function(doc) { - if (doc.chef_type == "node") { - emit(doc.name, doc); + describe "create_design_document" do + before(:each) do + @mock_design = { + "version" => 1, + "_rev" => 1 + } + @mock_data = { + "version" => 1, + "language" => "javascript", + "views" => { + "all" => { + "map" => <<-EOJS + function(doc) { + if (doc.chef_type == "node") { + emit(doc.name, doc); + } } - } - EOJS - }, + EOJS + }, + } } - } - @mock_rest.stub!(:get_rest).and_return(@mock_design) - @mock_rest.stub!(:put_rest).and_return(true) - Chef::REST.stub!(:new).and_return(@mock_rest) - @couchdb = Chef::CouchDB.new - @couchdb.stub!(:create_db).and_return(true) - end - - def do_create_design_document - @couchdb.create_design_document("bob", @mock_data) - end - - it "should create the database if it does not exist" do - @couchdb.should_receive(:create_db).and_return(true) - do_create_design_document - end - - it "should fetch the existing design document" do - @mock_rest.should_receive(:get_rest).with("chef/_design%2Fbob") - do_create_design_document - end - - it "should populate the _rev in the new design if the versions dont match" do - @mock_data["version"] = 2 - do_create_design_document - @mock_data["_rev"].should eql(1) - end - - it "should create the view if it requires updating" do - @mock_data["version"] = 2 - @mock_rest.should_receive(:put_rest).with("chef/_design%2Fbob", @mock_data) - do_create_design_document - end - - it "should not create the view if it does not require updating" do - @mock_data["version"] = 1 - @mock_rest.should_not_receive(:put_rest) - do_create_design_document + @mock_rest.stub!(:get_rest).and_return(@mock_design) + @mock_rest.stub!(:put_rest).and_return(true) + @couchdb.stub!(:create_db).and_return(true) + end + + def do_create_design_document + @couchdb.create_design_document("bob", @mock_data) + end + + it "should create the database if it does not exist" do + @couchdb.should_receive(:create_db).and_return(true) + do_create_design_document + end + + it "should fetch the existing design document" do + @mock_rest.should_receive(:get_rest).with("chef/_design/bob") + do_create_design_document + end + + it "should populate the _rev in the new design if the versions dont match" do + @mock_data["version"] = 2 + do_create_design_document + @mock_data["_rev"].should eql(1) + end + + it "should create the view if it requires updating" do + @mock_data["version"] = 2 + @mock_rest.should_receive(:put_rest).with("chef/_design%2Fbob", @mock_data) + do_create_design_document + end + + it "should not create the view if it does not require updating" do + @mock_data["version"] = 1 + @mock_rest.should_not_receive(:put_rest) + do_create_design_document + end end -end -describe Chef::CouchDB, "store" do - it "should put the object into couchdb" do - @mock_rest = mock("Chef::REST", :null_object => true) - @mock_rest.should_receive(:put_rest).with("chef/node_bob", {}).and_return(true) - Chef::REST.stub!(:new).and_return(@mock_rest) - Chef::CouchDB.new.store("node", "bob", {}) - end -end + describe "store" do + before(:each) do + @mock_results = { + "rows" => [ + "id" => 'a0934635-e111-45d9-8223-cb58e1c9434c' + ] + } + @couchdb.stub!(:get_view).with("id_map", "name_to_id", :key => [ "node", "bob" ]).and_return(@mock_results) + end -describe Chef::CouchDB, "load" do - it "should load the object from couchdb" do - @mock_rest = mock("Chef::REST", :null_object => true) - @mock_rest.should_receive(:get_rest).with("chef/node_bob").and_return(true) - Chef::REST.stub!(:new).and_return(@mock_rest) - Chef::CouchDB.new.load("node", "bob").should eql(true) - end -end + it "should put the object into couchdb with a pre-existing GUID" do + @mock_rest.should_receive(:put_rest).with("chef/#{@mock_results["rows"][0]["id"]}", {}).and_return(true) + @couchdb.store("node", "bob", {}) + end -describe Chef::CouchDB, "delete" do - before(:each) do - @mock_current = { - "version" => 1, - "_rev" => 1 - } - @mock_rest = mock("Chef::REST", :null_object => true) - @mock_rest.stub!(:get_rest).and_return(@mock_current) - @mock_rest.stub!(:delete_rest).and_return(true) - Chef::REST.stub!(:new).and_return(@mock_rest) - end - - def do_delete(rev=nil) - Chef::REST.stub!(:new).and_return(@mock_rest) - Chef::CouchDB.new.delete("node", "bob", rev) - end - - it "should remove the object from couchdb with a specific revision" do - @mock_rest.should_receive(:delete_rest).with("chef/node_bob?rev=1") - do_delete(1) - end - - it "should remove the object from couchdb based on the couchdb_rev of the current obj" do - mock_real = mock("Inflated Object") - mock_real.stub!(:respond_to?).and_return(true) - mock_real.stub!(:couchdb_rev).and_return(2) - @mock_rest.should_receive(:get_rest).with("chef/node_bob").and_return(mock_real) - @mock_rest.should_receive(:delete_rest).with("chef/node_bob?rev=2") - do_delete - end - - it "should remove the object from couchdb based on the current objects rev" do - @mock_rest.should_receive(:delete_rest).with("chef/node_bob?rev=1") - do_delete + it "should put the object into couchdb with a new GUID" do + @mock_results = { "rows" => [] } + @couchdb.stub!(:get_view).with("id_map", "name_to_id", :key => [ "node", "bob" ]).and_return(@mock_results) + UUIDTools::UUID.stub!(:random_create).and_return("aaaaaaaa-xxxx-xxxx-xxxx-xxxxxxxxxxx") + @mock_rest.should_receive(:put_rest).with("chef/aaaaaaaa-xxxx-xxxx-xxxx-xxxxxxxxxxx", {}).and_return(true) + @couchdb.store("node", "bob", {}) + end + + it "should send the object to nanite for indexing" do + Chef::Nanite.should_receive(:push) + @couchdb.store("node", "bob", {}) + end end -end -describe Chef::CouchDB, "list" do - before(:each) do - @mock_rest = mock("Chef::REST", :null_object => true, :url => "http://monkeypants") - Chef::REST.stub!(:new).and_return(@mock_rest) - @couch = Chef::CouchDB.new("http://monkeypants") - Chef::Config.stub!(:[]).with(:couchdb_database).and_return("chef") + describe "load" do + before(:each) do + @mock_node = Chef::Node.new() + @mock_node.name("bob") + @couchdb.stub!(:find_by_name).with("node", "bob").and_return(@mock_node) + end + + it "should load the object from couchdb" do + @couchdb.load("node", "bob").should eql(@mock_node) + end end - - describe "on couchdb 0.8" do - before do - Chef::Config.stub!(:[]).with(:couchdb_version).and_return(0.8) + + describe "delete" do + before(:each) do + @mock_current = { + "version" => 1, + "_rev" => 1 + } + @mock_rest.stub!(:get_rest).and_return(@mock_current) + @mock_rest.stub!(:delete_rest).and_return(true) + @mock_node = Chef::Node.new() + @mock_node.name("bob") + @mock_node.couchdb_rev = 15 + @couchdb.stub!(:find_by_name).with("node", "bob", true).and_return([ @mock_node, "ax" ]) end - it "should get the view for all objects if inflate is true" do - @mock_rest.should_receive(:get_rest).with("chef/_view/node/all").and_return(true) - @couch.list("node", true) + def do_delete(rev=nil) + @couchdb.delete("node", "bob", rev) end - - it "should get the view for just the object id's if inflate is false" do - @mock_rest.should_receive(:get_rest).with("chef/_view/node/all_id").and_return(true) - @couch.list("node", false) + + it "should remove the object from couchdb with a specific revision" do + @mock_rest.should_receive(:delete_rest).with("chef/ax?rev=1") + do_delete(1) + end + + it "should remove the object from couchdb based on the couchdb_rev of the current obj" do + @mock_rest.should_receive(:delete_rest).with("chef/ax?rev=15") + do_delete end end - describe "on couchdb 0.9" do - before do - Chef::Config.stub!(:[]).with(:couchdb_version).and_return(0.9) + describe "list" do + before(:each) do + Chef::Config.stub!(:[]).with(:couchdb_database).and_return("chef") + @mock_response = mock("Chef::CouchDB::Response", :null_object => true) end - it "should get the view for all objects if inflate is true" do - @mock_rest.should_receive(:get_rest).with("chef/_design/node/_view/all").and_return(true) - @couch.list("node", true) + describe "on couchdb 0.8" do + before(:each) do + Chef::Config.stub!(:[]).with(:couchdb_version).and_return(0.8) + end + + it "should get the view for all objects if inflate is true" do + @mock_rest.should_receive(:get_rest).with("chef/_view/node/all").and_return(@mock_response) + @couchdb.list("node", true) + end + + it "should get the view for just the object id's if inflate is false" do + @mock_rest.should_receive(:get_rest).with("chef/_view/node/all_id").and_return(@mock_response) + @couchdb.list("node", false) + end end - it "should get the view for just the object id's if inflate is false" do - @mock_rest.should_receive(:get_rest).with("chef/_design/node/_view/all_id").and_return(true) - @couch.list("node", false) + describe "on couchdb 0.9" do + before do + Chef::Config.stub!(:[]).with(:couchdb_version).and_return(0.9) + end + + it "should get the view for all objects if inflate is true" do + @mock_rest.should_receive(:get_rest).with("chef/_design/node/_view/all").and_return(@mock_response) + @couchdb.list("node", true) + end + + it "should get the view for just the object id's if inflate is false" do + @mock_rest.should_receive(:get_rest).with("chef/_design/node/_view/all_id").and_return(@mock_response) + @couchdb.list("node", false) + end end end -end -describe Chef::CouchDB, "has_key?" do - before(:each) do - @mock_rest = mock("Chef::REST", :null_object => true) - Chef::REST.stub!(:new).and_return(@mock_rest) - end - - it "should return true if the object exists" do - @mock_rest.should_receive(:get_rest).and_return(true) - Chef::CouchDB.new.has_key?("node", "bob").should eql(true) - end - - it "should return false if the object does not exist" do - @mock_rest.should_receive(:get_rest).and_raise(ArgumentError) - Chef::CouchDB.new.has_key?("node", "bob").should eql(false) + describe "has_key?" do + it "should return true if the object exists" do + @couchdb.stub!(:find_by_name).with("node", "bob").and_return(true) + @couchdb.has_key?("node", "bob").should eql(true) + end + + it "should return false if the object does not exist" do + @couchdb.stub!(:find_by_name).and_raise(Chef::Exceptions::CouchDBNotFound) + @couchdb.has_key?("node", "bob").should eql(false) + end end + end + + + describe Chef::CouchDB, "get_view" do before do @mock_rest = mock("Chef::REST", :null_object => true, :url => "http://monkeypants") @@ -287,7 +296,7 @@ describe Chef::CouchDB, "view_uri" do @mock_rest.should_receive(:run_request).with( :GET, URI.parse("http://monkeypants/"), - false, + {}, 10, false ).and_return({ "version" => "0.9" }) chef/spec/unit/couchdb_spec.rb @@ -489,7 +489,7 @@ describe Chef::Node::Attribute do { "one" => { "two" => "three" }, "hut" => { "two" => "three" }, - "place" => { }, + "place" => { } }, { "one" => { "four" => "five" }, chef/spec/unit/node/attribute_spec.rb @@ -21,6 +21,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper")) describe Chef::Node do before(:each) do Chef::Config.node_path(File.join(File.dirname(__FILE__), "..", "data", "nodes")) + Nanite.stub!(:request).and_return(true) @node = Chef::Node.new() end @@ -263,17 +264,6 @@ describe Chef::Node do end end - describe "to_index" do - before(:each) do - @node.foo("bar") - end - - it "should return a hash with :index attributes" do - @node.name("airplane") - @node.to_index.should == { "foo" => "bar", "index_name" => "node", "id" => "node_airplane", "name" => "airplane" } - end - end - describe "to_s" do it "should turn into a string like node[name]" do @node.name("airplane") @@ -281,7 +271,71 @@ describe Chef::Node do end end - describe "couchdb" do + describe "api model" do + before(:each) do + @rest = mock("Chef::REST") + Chef::REST.stub!(:new).and_return(@rest) + @query = mock("Chef::Search::Query") + Chef::Search::Query.stub!(:new).and_return(@query) + end + + describe "list" do + describe "inflated" do + it "should return a hash of node names and objects" do + n1 = mock("Chef::Node", :name => "one") + @query.should_receive(:search).with(:node).and_yield(n1) + r = Chef::Node.list(true) + r["one"].should == n1 + end + end + + it "should return a hash of node names and urls" do + @rest.should_receive(:get_rest).and_return({ "one" => "http://foo" }) + r = Chef::Node.list + r["one"].should == "http://foo" + end + end + + describe "load" do + it "should load a node by name" do + @rest.should_receive(:get_rest).with("nodes/monkey").and_return("foo") + Chef::Node.load("monkey").should == "foo" + end + end + + describe "destroy" do + it "should destroy a node" do + @rest.should_receive(:delete_rest).with("nodes/monkey").and_return("foo") + @node.name("monkey") + @node.destroy + end + end + + describe "save" do + it "should update a node if it already exists" do + @node.name("monkey") + @rest.should_receive(:put_rest).with("nodes/monkey", @node).and_return("foo") + @node.save + end + + it "should not try and create if it can update" do + @node.name("monkey") + @rest.should_receive(:put_rest).with("nodes/monkey", @node).and_return("foo") + @rest.should_not_receive(:post_rest) + @node.save + end + + it "should create if it cannot update" do + @node.name("monkey") + exception = mock("404 error", :code => "404") + @rest.should_receive(:put_rest).and_raise(Net::HTTPServerException.new("foo", exception)) + @rest.should_receive(:post_rest).with("nodes", @node) + @node.save + end + end + end + + describe "couchdb model" do before(:each) do @mock_couch = mock("Chef::CouchDB") end @@ -295,15 +349,15 @@ describe Chef::Node do end it "should retrieve a list of nodes from CouchDB" do - Chef::Node.list.should eql(["avenue"]) + Chef::Node.cdb_list.should eql(["avenue"]) end it "should return just the ids if inflate is false" do - Chef::Node.list(false).should eql(["avenue"]) + Chef::Node.cdb_list(false).should eql(["avenue"]) end it "should return the full objects if inflate is true" do - Chef::Node.list(true).should eql(["a"]) + Chef::Node.cdb_list(true).should eql(["a"]) end end @@ -311,7 +365,7 @@ describe Chef::Node do it "should load a node from couchdb by name" do @mock_couch.should_receive(:load).with("node", "coffee").and_return(true) Chef::CouchDB.stub!(:new).and_return(@mock_couch) - Chef::Node.load("coffee") + Chef::Node.cdb_load("coffee") end end @@ -322,8 +376,7 @@ describe Chef::Node do node = Chef::Node.new node.name "bob" node.couchdb_rev = 1 - Chef::Queue.should_receive(:send_msg).with(:queue, :remove, node) - node.destroy + node.cdb_destroy end end @@ -331,20 +384,18 @@ describe Chef::Node do before(:each) do @mock_couch.stub!(:store).and_return({ "rev" => 33 }) Chef::CouchDB.stub!(:new).and_return(@mock_couch) - Chef::Queue.stub!(:send_msg).and_return(true) @node = Chef::Node.new @node.name "bob" @node.couchdb_rev = 1 end it "should save the node to couchdb" do - Chef::Queue.should_receive(:send_msg).with(:queue, :index, @node) @mock_couch.should_receive(:store).with("node", "bob", @node).and_return({ "rev" => 33 }) - @node.save + @node.cdb_save end it "should store the new couchdb_rev" do - @node.save + @node.cdb_save @node.couchdb_rev.should eql(33) end end chef/spec/unit/node_spec.rb @@ -53,11 +53,16 @@ describe Chef::Provider::Deploy do @provider.should_receive(:cleanup!) @provider.deploy end - - it "does not deploy when using the :deploy action if there is already a deploy at release_path" do + + it "should not deploy if there is already a deploy at release_path, and it is the current release" do @provider.stub!(:all_releases).and_return([@expected_release_dir]) - @provider.should_not_receive(:enforce_ownership) - @provider.should_not_receive(:update_cached_repo) + @provider.should_not_receive(:deploy) + @provider.action_deploy + end + + it "should call action_rollback if there is already a deploy of this revision at release_path, and it is not the current release" do + @provider.stub!(:all_releases).and_return([@expected_release_dir, "102021"]) + @provider.should_receive(:action_rollback) @provider.action_deploy end @@ -80,17 +85,59 @@ describe Chef::Provider::Deploy do @provider.action_force_deploy end - it "sets the release path to the penultimate release, symlinks, and rm's the last release on rollback" do - @provider.unstub!(:release_path) - all_releases = ["/my/deploy/dir/releases/20040815162342", "/my/deploy/dir/releases/20040700000000", - "/my/deploy/dir/releases/20040600000000", "/my/deploy/dir/releases/20040500000000"].sort! - Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases) - @provider.should_receive(:symlink) - FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342") - @provider.action_rollback - @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000") + + describe "on systems without broken Dir.glob results" do + it "sets the release path to the penultimate release when one is not specified, symlinks, and rm's the last release on rollback" do + @provider.stub!(:release_path).and_return("/my/deploy/dir/releases/3") + all_releases = ["/my/deploy/dir/releases/1", "/my/deploy/dir/releases/2", "/my/deploy/dir/releases/3", "/my/deploy/dir/releases/4", "/my/deploy/dir/releases/5"] + Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases) + @provider.should_receive(:symlink) + FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/4") + FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/5") + @provider.action_rollback + @provider.release_path.should eql("/my/deploy/dir/releases/3") + end + + it "sets the release path to the specified release, symlinks, and rm's any newer releases on rollback" do + @provider.unstub!(:release_path) + all_releases = ["/my/deploy/dir/releases/20040815162342", "/my/deploy/dir/releases/20040700000000", + "/my/deploy/dir/releases/20040600000000", "/my/deploy/dir/releases/20040500000000"].sort! + Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases) + @provider.should_receive(:symlink) + FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342") + @provider.action_rollback + @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000") + end + + it "sets the release path to the penultimate release, symlinks, and rm's the last release on rollback" do + @provider.unstub!(:release_path) + all_releases = [ "/my/deploy/dir/releases/20040815162342", + "/my/deploy/dir/releases/20040700000000", + "/my/deploy/dir/releases/20040600000000", + "/my/deploy/dir/releases/20040500000000"] + Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases) + @provider.should_receive(:symlink) + FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342") + @provider.action_rollback + @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000") + end end - + + describe "CHEF-628: on systems with broken Dir.glob results" do + it "sets the release path to the penultimate release, symlinks, and rm's the last release on rollback" do + @provider.unstub!(:release_path) + all_releases = [ "/my/deploy/dir/releases/20040500000000", + "/my/deploy/dir/releases/20040600000000", + "/my/deploy/dir/releases/20040700000000", + "/my/deploy/dir/releases/20040815162342" ] + Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases) + @provider.should_receive(:symlink) + FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342") + @provider.action_rollback + @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000") + end + end + it "raises a runtime error when there's no release to rollback to" do all_releases = [] Dir.stub!(:glob).with("/my/deploy/dir/releases/*").and_return(all_releases) chef/spec/unit/provider/deploy_spec.rb @@ -129,7 +129,7 @@ describe Chef::Provider::Git do "b7d19519a1c15f1c1a324e2683bd728b6198ce5a\trefs/tags/0.7.8^{}\n"+ "ebc1b392fe7e8f0fbabc305c299b4d365d2b4d9b\trefs/tags/chef-server-package" @resource.revision '' - @stdout.stub(:string).and_return(lots_of_shas) + @stdout.stub!(:string).and_return(lots_of_shas) @provider.should_receive(:popen4).and_yield("pid","stdin",@stdout,@stderr).and_return(@exitstatus) @provider.revision_sha.should eql("28af684d8460ba4793eda3e7ac238c864a5d029a") end @@ -199,13 +199,15 @@ describe Chef::Provider::Git do @provider.should_receive(:clone) @provider.should_receive(:checkout) @provider.should_receive(:enable_submodules) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_checkout end - + it "does a sync by running the sync command" do ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true) ::Dir.stub!(:entries).and_return(['.','..',"lib", "spec"]) @provider.should_receive(:sync) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_sync end @@ -213,6 +215,7 @@ describe Chef::Provider::Git do ::File.stub!(:exist?).with("/my/deploy/dir").and_return(false) @provider.should_receive(:action_checkout) @provider.should_not_receive(:run_command) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_sync end @@ -222,13 +225,15 @@ describe Chef::Provider::Git do @provider.stub!(:sync_command).and_return("huzzah!") @provider.should_receive(:action_checkout) @provider.should_not_receive(:run_command).with(:command => "huzzah!", :cwd => "/my/deploy/dir") + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_sync end it "does an export by cloning the repo then removing the .git directory" do @provider.should_receive(:action_checkout) FileUtils.should_receive(:rm_rf).with(@resource.destination + "/.git") + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_export end -end \ No newline at end of file +end chef/spec/unit/provider/git_spec.rb @@ -145,6 +145,7 @@ end describe Chef::Provider::Group::Usermod, "load_current_resource" do before do @node = mock("Chef::Node", :null_object => true) + Chef::Node.stub!(:new).and_return(@node) @new_resource = mock("Chef::Resource::Group", :null_object => true, :group_name => "aj") @provider = Chef::Provider::Group::Usermod.new(@node, @new_resource) File.stub!(:exists?).and_return(false) chef/spec/unit/provider/group/groupadd_spec.rb @@ -47,8 +47,8 @@ describe Chef::Provider::HttpRequest, "load_current_resource" do @provider = Chef::Provider::HttpRequest.new(@node, @new_resource) end - it "should set up a Chef::REST client" do - Chef::REST.should_receive(:new).with(@new_resource.url) + it "should set up a Chef::REST client, with no authentication" do + Chef::REST.should_receive(:new).with(@new_resource.url, nil, nil) @provider.load_current_resource end end @@ -83,7 +83,7 @@ describe Chef::Provider::HttpRequest, "action_get" do end it "should run a GET request" do - @rest.should_receive(:run_request).with(:GET, @rest.create_url, false, 10, false) + @rest.should_receive(:run_request).with(:GET, @rest.create_url, {}, false, 10, false) @provider.action_get end @@ -117,13 +117,13 @@ describe Chef::Provider::HttpRequest, "action_put" do end it "should run a PUT request with the message as the payload" do - @rest.should_receive(:run_request).with(:PUT, @rest.create_url, @new_resource.message, 10, false) + @rest.should_receive(:run_request).with(:PUT, @rest.create_url, {}, @new_resource.message, 10, false) @provider.action_put end it "should inflate a message block at runtime" do @new_resource.stub!(:message).and_return(lambda { "return" }) - @rest.should_receive(:run_request).with(:PUT, @rest.create_url, "return", 10, false) + @rest.should_receive(:run_request).with(:PUT, @rest.create_url, {}, "return", 10, false) @provider.action_put end @@ -157,13 +157,13 @@ describe Chef::Provider::HttpRequest, "action_post" do end it "should run a PUT request with the message as the payload" do - @rest.should_receive(:run_request).with(:POST, @rest.create_url, @new_resource.message, 10, false) + @rest.should_receive(:run_request).with(:POST, @rest.create_url, {}, @new_resource.message, 10, false) @provider.action_post end it "should inflate a message block at runtime" do @new_resource.stub!(:message).and_return(lambda { "return" }) - @rest.should_receive(:run_request).with(:POST, @rest.create_url, "return", 10, false) + @rest.should_receive(:run_request).with(:POST, @rest.create_url, {}, "return", 10, false) @provider.action_post end @@ -197,7 +197,7 @@ describe Chef::Provider::HttpRequest, "action_delete" do end it "should run a DELETE request" do - @rest.should_receive(:run_request).with(:DELETE, @rest.create_url, false, 10, false) + @rest.should_receive(:run_request).with(:DELETE, @rest.create_url, {}, false, 10, false) @provider.action_delete end @@ -205,4 +205,4 @@ describe Chef::Provider::HttpRequest, "action_delete" do @new_resource.should_receive(:updated=).with(true) @provider.action_delete end -end \ No newline at end of file +end chef/spec/unit/provider/http_request_spec.rb @@ -59,6 +59,12 @@ describe Chef::Provider::Package::Portage, "load_current_resource" do @current_resource.should_receive(:version).with("1.0.0") @provider.load_current_resource end + + it "should return a current resource with the correct version if the package is found with revision" do + ::Dir.stub!(:entries).and_return("git-1.0.0-r1") + @current_resource.should_receive(:version).with("1.0.0-r1") + @provider.load_current_resource + end it "should return a current resource with a nil version if the package is not found" do ::Dir.stub!(:entries).and_return("notgit-1.0.0") chef/spec/unit/provider/package/portage_spec.rb @@ -129,12 +129,6 @@ describe Chef::Provider::Service::Freebsd, "load_current_resource" do @provider.load_current_resource end - it "should close stdin inside popen" do - @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status) - @stdin.should_receive(:close).and_return(true) - @provider.load_current_resource - end - it "should read stdout of the ps command" do @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status) @stdout.should_receive(:each_line).and_return(true) chef/spec/unit/provider/service/freebsd_service_spec.rb @@ -159,12 +159,14 @@ describe Chef::Provider::Subversion do it "runs the checkout command for action_checkout" do expected_cmd = "svn checkout -q -r12345 http://svn.example.org/trunk/ /my/deploy/dir" @provider.should_receive(:run_command).with(:command => expected_cmd) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_checkout end it "does a checkout for action_sync if there's no deploy dir" do ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(false) @provider.should_receive(:action_checkout) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_sync end @@ -172,6 +174,7 @@ describe Chef::Provider::Subversion do ::File.should_receive(:exist?).with("/my/deploy/dir/.svn").and_return(true) ::Dir.should_receive(:entries).with("/my/deploy/dir").and_return(['.','..']) @provider.should_receive(:action_checkout) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_sync end @@ -180,12 +183,14 @@ describe Chef::Provider::Subversion do ::Dir.should_receive(:entries).with("/my/deploy/dir").and_return(['.','..','the','app','exists']) expected_cmd = "svn update -q -r12345 /my/deploy/dir" @provider.should_receive(:run_command).with(:command => expected_cmd) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_sync end it "runs the export_command on action_export" do expected_cmd = "svn export -q -r12345 http://svn.example.org/trunk/ /my/deploy/dir" @provider.should_receive(:run_command).with(:command => expected_cmd) + @resource.should_receive(:updated=).at_least(1).times.with(true) @provider.action_export end chef/spec/unit/provider/subversion_spec.rb @@ -73,7 +73,6 @@ describe Chef::Resource::Deploy do resource_has_a_boolean_attribute(:migrate, :defaults_to=>false) resource_has_a_boolean_attribute(:enable_submodules, :defaults_to=>false) resource_has_a_boolean_attribute(:shallow_clone, :defaults_to=>false) - resource_has_a_boolean_attribute(:force_deploy, :defaults_to=>false) it "uses the first argument as the deploy directory" do @resource.deploy_to.should eql("/my/deploy/dir") chef/spec/unit/resource/deploy_spec.rb @@ -20,333 +20,365 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper")) require 'uri' require 'net/https' -describe Chef::REST, "initialize method" do - it "should create a new Chef::REST" do - Chef::REST.new("url").should be_kind_of(Chef::REST) +describe Chef::REST do + before(:each) do + Chef::REST::CookieJar.stub!(:instance).and_return({}) + @rest = Chef::REST.new("url", nil, nil) end -end -describe Chef::REST, "get_rest method" do - it "should create a url from the path and base url" do - URI.should_receive(:parse).with("url/monkey") - r = Chef::REST.new("url") - r.stub!(:run_request) - r.get_rest("monkey") - end - - it "should call run_request :GET with the composed url object" do - URI.stub!(:parse).and_return(true) - r = Chef::REST.new("url") - r.should_receive(:run_request).with(:GET, true, false, 10, false).and_return(true) - r.get_rest("monkey") + describe "initialize" do + it "should create a new Chef::REST" do + @rest.should be_kind_of(Chef::REST) + end end -end -describe Chef::REST, "delete_rest method" do - it "should create a url from the path and base url" do - URI.should_receive(:parse).with("url/monkey") - r = Chef::REST.new("url") - r.stub!(:run_request) - r.delete_rest("monkey") - end - - it "should call run_request :DELETE with the composed url object" do - URI.stub!(:parse).and_return(true) - r = Chef::REST.new("url") - r.should_receive(:run_request).with(:DELETE, true).and_return(true) - r.delete_rest("monkey") - end -end + describe "load_signing_key" do + before(:each) do + @private_key = <<EOH +-----BEGIN RSA PRIVATE KEY----- +MIIEowIBAAKCAQEAx8xAfO2BO8kUughpjWwHPN2rgDcES15PbMEGe6OdJgjFARkt +FMdEusbGxmXKpk51Ggxi2P6ZYEoZfniZWt4qSt4i1vanDayRlJ1qoRCOaYj5cQS7 +gpHspHWqkY3HfGvx4svdutQ06o/gypx2QYfi68YrIUQexPiTUhsnP9FlgNt40Rl1 +YgBiIlJUk7d3q+1b/+POTNKPeyjGK9hoTloplbSx+cYdZgc4/YpU0eLBoHPuPv5l +QD+Y8VNS39bvY2NWbCqhV508gExAK26FxXTDNpi2mTZmbRZ8U0PKrCgF6gBSeod5 +EdQnNgoZHmA2fzfPHWfJd2OEuMcNM7DWpPDizQIDAQABAoIBAAGVDYGvw9E8Y2yh +umxDSb9ipgQK637JTWm4EZwTDKCLezvp/iBm/5VXE6XoknVEs8q0BGhhg8dubstA +mz5L+hvDrJT1ORdzoWeC46BI6EfPrOIHPpDnJO+cevBSJh1HIZBBOw1KtuyQnSAd +oxYbxGFHnXnS90dqDIie7G2l897UWoiQWNMLY+A+l5H4GLC+4Phq02pLd4OQwXA3 +Nd+3Nq69aOeccyfSDeeG7u35TKrjQPIxU210aR18d/0trR20BKsKbT30GPE1tQQd +jm4uReSPttTQ+NjwBQKKYmO2F9b9MPzmQ7c+KycBRmf+IOgZeZ54JN0GzUXsDTjJ ++ZSgdgUCgYEA41aetBJwsKkF973gL54QCB5vFhRw3TdUgYhQgz04B5JGouGTSALy +u1XtO6il65Zf6FwFSzXiggYYxTKyP/zwL88CQAVA7rleyhoZrw2bD6R2RZLivRba +50rstltUbjevd96TagFY7i9gVHL9E6DKJH4unZfIM0Bl2IZQraqCR8MCgYEA4PzC +FfUwiLa5drN6OVWZZfwxOeMbQUsYVeq7pHyeuvIe0euhcCLabBqfVt0pxqf1hem+ +l2+PnSKtvbI9siwt6WvJCtB3e/3aHOA3d6Y9TYxoyJAK007mRlQbbgqLzG83tZH2 +twO2tjo+h1+nv5yjE7aF9ItszegwTWsupvR+Ei8CgYAy0nt6MCEnLTIbV0RWANT+ +q6cT3Y/5tFPc/Vdab4YmEypdYWZmk9olzSjSzHoDN8PLEz9PuAUiIjDJbPLyYR5k +4bdUDpicha5OKhWRz83Zal/SX+r2cLSRPmu6vKIcXbCJcKWt7g0uekLjvi0bhTeL +fvX23yavZnceN7Czkkm7twKBgEFTgrNHdykrDRzXLhT5ssm2+UAani5ONKm1t3gi +KyCS7rn7FevuYsdiz4M0Qk4JNLQGU6262dNBX3smBt32D/qnrj8ymo7o/WzG+bQH +E+OxcjdSA6KpVRl0kGZaL49Td7SDxkQLkwDEVqWN87IiNAOkSq7f0N7UnTnNdkVJ +1lVHAoGBANYgMoEj7gIJdch7hMdQcFfq9+4ntAAbsl3JFW+T9ChATn0XHAylP9ha +ZaGlRrC7vxcF06vMe0HXyH1XVK3J9186zliTa4oDjkQ0D5X7Ga7KktLXAmQTysUH +V3jwIQbAF6LqLUnGOq6rJzQxrWKvFt0mVDyuJzIJGSbnN/Sl5J6P +-----END RSA PRIVATE KEY----- +EOH + IO.stub!(:read).and_return(@private_key) + end -describe Chef::REST, "post_rest method" do - it "should create a url from the path and base url" do - URI.should_receive(:parse).with("url/monkey") - r = Chef::REST.new("url") - r.stub!(:run_request) - r.post_rest("monkey", "data") - end - - it "should call run_request :POST with the composed url object and data" do - URI.stub!(:parse).and_return(true) - r = Chef::REST.new("url") - r.should_receive(:run_request).with(:POST, true, "data").and_return(true) - r.post_rest("monkey", "data") - end -end + it "should return the contents of the key file" do + File.stub!(:exists?).and_return(true) + File.stub!(:readable?).and_return(true) + @rest.load_signing_key("/tmp/keyfile.pem").should be(@private_key) + end -describe Chef::REST, "put_rest method" do - it "should create a url from the path and base url" do - URI.should_receive(:parse).with("url/monkey") - r = Chef::REST.new("url") - r.stub!(:run_request) - r.put_rest("monkey", "data") - end - - it "should call run_request :PUT with the composed url object and data" do - URI.stub!(:parse).and_return(true) - r = Chef::REST.new("url") - r.should_receive(:run_request).with(:PUT, true, "data").and_return(true) - r.put_rest("monkey", "data") - end -end + it "should raise a Chef::Exceptions::PrivateKeyMissing exception if the key cannot be found" do + File.stub!(:exists?).and_return(false) + File.stub!(:readable?).and_return(true) #42! + lambda { + @rest.load_signing_key("/tmp/keyfile.pem") + }.should raise_error(Chef::Exceptions::PrivateKeyMissing) + end -describe Chef::REST, "run_request method" do - before(:each) do - Chef::REST::CookieJar.stub!(:instance).and_return({}) - @r = Chef::REST.new("url") - @url_mock = mock("URI", :null_object => true) - @url_mock.stub!(:host).and_return("one") - @url_mock.stub!(:port).and_return("80") - @url_mock.stub!(:path).and_return("/") - @url_mock.stub!(:query).and_return("foo=bar") - @url_mock.stub!(:scheme).and_return("https") - @url_mock.stub!(:user).and_return(nil) - @url_mock.stub!(:password).and_return(nil) - @url_mock.stub!(:to_s).and_return("https://one:80/?foo=bar") - @http_response_mock = mock("Net::HTTPSuccess", :null_object => true) - @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(true) - @http_response_mock.stub!(:body).and_return("ninja") - @http_response_mock.stub!(:error!).and_return(true) - @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "5" }) - @http_mock = mock("Net::HTTP", :null_object => true) - @http_mock.stub!(:verify_mode=).and_return(true) - @http_mock.stub!(:read_timeout=).and_return(true) - @http_mock.stub!(:use_ssl=).with(true).and_return(true) - @data_mock = mock("Data", :null_object => true) - @data_mock.stub!(:to_json).and_return('{ "one": "two" }') - @request_mock = mock("Request", :null_object => true) - @request_mock.stub!(:body=).and_return(true) - @request_mock.stub!(:method).and_return(true) - @request_mock.stub!(:path).and_return(true) - @http_mock.stub!(:request).and_return(@http_response_mock) - @tf_mock = mock(Tempfile, { :print => true, :close => true, :write => true }) - Tempfile.stub!(:new).with("chef-rest").and_return(@tf_mock) - end - - def do_run_request(method=:GET, data=false, limit=10, raw=false) - Net::HTTP.stub!(:new).and_return(@http_mock) - @r.run_request(method, @url_mock, data, limit, raw) + it "should raise a Chef::Exceptions::PrivateKeyMissing exception if the key cannot be read" do + File.stub!(:exists?).and_return(true) + File.stub!(:readable?).and_return(false) + lambda { + @rest.load_signing_key("/tmp/keyfile.pem") + }.should raise_error(Chef::Exceptions::PrivateKeyMissing) + end end - - it "should raise an exception if the redirect limit is 0" do - lambda { @r.run_request(:GET, "/", false, 0)}.should raise_error(ArgumentError) + + describe "get_rest" do + it "should create a url from the path and base url" do + URI.should_receive(:parse).with("url/monkey") + @rest.stub!(:run_request) + @rest.get_rest("monkey") + end + + it "should call run_request :GET with the composed url object" do + URI.stub!(:parse).and_return(true) + @rest.should_receive(:run_request).with(:GET, true, {}, false, 10, false).and_return(true) + @rest.get_rest("monkey") + end end - it "should not fail if URI contains %d characters" do - @http_response_mock.stub!(:read_body).and_yield("ninja") - @url_mock.stub!(:path).and_return("/myfile?Expires=1247484042&Signature=hpK%2BbHchAmUCErdz1yCBPazzGRQ%3D") - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @http_response_mock.should_receive(:read_body).and_return(true) - do_run_request(:GET, false, 10, true) + describe "delete_rest" do + it "should create a url from the path and base url" do + URI.should_receive(:parse).with("url/monkey") + @rest.stub!(:run_request) + @rest.delete_rest("monkey") + end + + it "should call run_request :DELETE with the composed url object" do + URI.stub!(:parse).and_return(true) + @rest.should_receive(:run_request).with(:DELETE, true, {}).and_return(true) + @rest.delete_rest("monkey") + end end - - it "should use SSL if the url starts with https" do - @url_mock.should_receive(:scheme).and_return("https") - @http_mock.should_receive(:use_ssl=).with(true).and_return(true) - do_run_request + + describe "post_rest" do + it "should create a url from the path and base url" do + URI.should_receive(:parse).with("url/monkey") + @rest.stub!(:run_request) + @rest.post_rest("monkey", "data") + end + + it "should call run_request :POST with the composed url object and data" do + URI.stub!(:parse).and_return(true) + @rest.should_receive(:run_request).with(:POST, true, {}, "data").and_return(true) + @rest.post_rest("monkey", "data") + end end - - it "should set the OpenSSL Verify Mode to verify_none if requested" do - @http_mock.should_receive(:verify_mode=).and_return(true) - do_run_request + + describe "put_rest" do + it "should create a url from the path and base url" do + URI.should_receive(:parse).with("url/monkey") + @rest.stub!(:run_request) + @rest.put_rest("monkey", "data") + end + + it "should call run_request :PUT with the composed url object and data" do + URI.stub!(:parse).and_return(true) + @rest.should_receive(:run_request).with(:PUT, true, {}, "data").and_return(true) + @rest.put_rest("monkey", "data") + end end - - describe "with a client SSL cert" do + + describe Chef::REST, "run_request method" do before(:each) do - Chef::Config[:ssl_client_cert] = "/etc/chef/client-cert.pem" - Chef::Config[:ssl_client_key] = "/etc/chef/client-cert.key" - File.stub!(:exists?).with("/etc/chef/client-cert.pem").and_return(true) - File.stub!(:exists?).with("/etc/chef/client-cert.key").and_return(true) - File.stub!(:read).with("/etc/chef/client-cert.pem").and_return("monkey magic client") - File.stub!(:read).with("/etc/chef/client-cert.key").and_return("monkey magic key") - OpenSSL::X509::Certificate.stub!(:new).and_return("monkey magic client data") - OpenSSL::PKey::RSA.stub!(:new).and_return("monkey magic key data") + @url_mock = mock("URI", :null_object => true) + @url_mock.stub!(:host).and_return("one") + @url_mock.stub!(:port).and_return("80") + @url_mock.stub!(:path).and_return("/") + @url_mock.stub!(:query).and_return("foo=bar") + @url_mock.stub!(:scheme).and_return("https") + @url_mock.stub!(:to_s).and_return("https://one:80/?foo=bar") + @http_response_mock = mock("Net::HTTPSuccess", :null_object => true) + @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(true) + @http_response_mock.stub!(:body).and_return("ninja") + @http_response_mock.stub!(:error!).and_return(true) + @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "5" }) + @http_mock = mock("Net::HTTP", :null_object => true) + @http_mock.stub!(:verify_mode=).and_return(true) + @http_mock.stub!(:read_timeout=).and_return(true) + @http_mock.stub!(:use_ssl=).with(true).and_return(true) + @data_mock = mock("Data", :null_object => true) + @data_mock.stub!(:to_json).and_return('{ "one": "two" }') + @request_mock = mock("Request", :null_object => true) + @request_mock.stub!(:body=).and_return(true) + @request_mock.stub!(:method).and_return(true) + @request_mock.stub!(:path).and_return(true) + @http_mock.stub!(:request).and_return(@http_response_mock) + @tf_mock = mock(Tempfile, { :print => true, :close => true, :write => true }) + Tempfile.stub!(:new).with("chef-rest").and_return(@tf_mock) end - - it "should check that the client cert file exists" do - File.should_receive(:exists?).with("/etc/chef/client-cert.pem").and_return(true) + + def do_run_request(method=:GET, data=false, limit=10, raw=false) + Net::HTTP.stub!(:new).and_return(@http_mock) + @rest.run_request(method, @url_mock, {}, data, limit, raw) + end + + it "should raise an exception if the redirect limit is 0" do + lambda { @rest.run_request(:GET, "/", {}, false, 0)}.should raise_error(ArgumentError) + end + + it "should use SSL if the url starts with https" do + @url_mock.should_receive(:scheme).and_return("https") + @http_mock.should_receive(:use_ssl=).with(true).and_return(true) do_run_request end - - it "should read the cert file" do - File.should_receive(:read).with("/etc/chef/client-cert.pem").and_return("monkey magic client") + + it "should set the OpenSSL Verify Mode to verify_none if requested" do + @http_mock.should_receive(:verify_mode=).and_return(true) do_run_request end + + describe "with a client SSL cert" do + before(:each) do + Chef::Config[:ssl_client_cert] = "/etc/chef/client-cert.pem" + Chef::Config[:ssl_client_key] = "/etc/chef/client-cert.key" + File.stub!(:exists?).with("/etc/chef/client-cert.pem").and_return(true) + File.stub!(:exists?).with("/etc/chef/client-cert.key").and_return(true) + File.stub!(:read).with("/etc/chef/client-cert.pem").and_return("monkey magic client") + File.stub!(:read).with("/etc/chef/client-cert.key").and_return("monkey magic key") + OpenSSL::X509::Certificate.stub!(:new).and_return("monkey magic client data") + OpenSSL::PKey::RSA.stub!(:new).and_return("monkey magic key data") + end + + it "should check that the client cert file exists" do + File.should_receive(:exists?).with("/etc/chef/client-cert.pem").and_return(true) + do_run_request + end + + it "should read the cert file" do + File.should_receive(:read).with("/etc/chef/client-cert.pem").and_return("monkey magic client") + do_run_request + end + + it "should read the cert into OpenSSL" do + OpenSSL::X509::Certificate.should_receive(:new).and_return("monkey magic client data") + do_run_request + end + + it "should set the cert" do + @http_mock.should_receive(:cert=).and_return(true) + do_run_request + end + + it "should read the key file" do + File.should_receive(:read).with("/etc/chef/client-cert.key").and_return("monkey magic key") + do_run_request + end + + it "should read the key into OpenSSL" do + OpenSSL::PKey::RSA.should_receive(:new).and_return("monkey magic key data") + do_run_request + end + + it "should set the key" do + @http_mock.should_receive(:key=).and_return(true) + do_run_request + end - it "should read the cert into OpenSSL" do - OpenSSL::X509::Certificate.should_receive(:new).and_return("monkey magic client data") - do_run_request end - it "should set the cert" do - @http_mock.should_receive(:cert=).and_return(true) + it "should set a read timeout based on the rest_timeout config option" do + Chef::Config[:rest_timeout] = 10 + @http_mock.should_receive(:read_timeout=).with(10).and_return(true) do_run_request end - - it "should read the key file" do - File.should_receive(:read).with("/etc/chef/client-cert.key").and_return("monkey magic key") + + it "should set the cookie for this request if one exists for the given host:port" do + @rest.cookies = { "#{@url_mock.host}:#{@url_mock.port}" => "cookie monster" } + Net::HTTP::Get.should_receive(:new).with("/?foo=bar", + { 'Accept' => 'application/json', 'Cookie' => 'cookie monster' } + ).and_return(@request_mock) do_run_request + @rest.cookies = Hash.new end - - it "should read the key into OpenSSL" do - OpenSSL::PKey::RSA.should_receive(:new).and_return("monkey magic key data") + + it "should build a new HTTP GET request" do + Net::HTTP::Get.should_receive(:new).with("/?foo=bar", + { 'Accept' => 'application/json' } + ).and_return(@request_mock) do_run_request end - - it "should set the key" do - @http_mock.should_receive(:key=).and_return(true) + + it "should build a new HTTP POST request" do + Net::HTTP::Post.should_receive(:new).with("/?foo=bar", + { 'Accept' => 'application/json', "Content-Type" => 'application/json' } + ).and_return(@request_mock) + do_run_request(:POST, @data_mock) + end + + it "should build a new HTTP PUT request" do + Net::HTTP::Put.should_receive(:new).with("/?foo=bar", + { 'Accept' => 'application/json', "Content-Type" => 'application/json' } + ).and_return(@request_mock) + do_run_request(:PUT, @data_mock) + end + + it "should build a new HTTP DELETE request" do + Net::HTTP::Delete.should_receive(:new).with("/?foo=bar", + { 'Accept' => 'application/json' } + ).and_return(@request_mock) + do_run_request(:DELETE) + end + + it "should raise an error if the method is not GET/PUT/POST/DELETE" do + lambda { do_run_request(:MONKEY) }.should raise_error(ArgumentError) + end + + it "should run an http request" do + @http_mock.should_receive(:request).and_return(@http_response_mock) do_run_request end - - end - - it "should set a read timeout based on the rest_timeout config option" do - Chef::Config[:rest_timeout] = 10 - @http_mock.should_receive(:read_timeout=).with(10).and_return(true) - do_run_request - end - - it "should set the cookie for this request if one exists for the given host:port" do - @r.cookies = { "#{@url_mock.host}:#{@url_mock.port}" => "cookie monster" } - Net::HTTP::Get.should_receive(:new).with("/?foo=bar", - { 'Accept' => 'application/json', 'Cookie' => 'cookie monster' } - ).and_return(@request_mock) - do_run_request - end - - it "should build a new HTTP GET request" do - Net::HTTP::Get.should_receive(:new).with("/?foo=bar", - { 'Accept' => 'application/json' } - ).and_return(@request_mock) - do_run_request - end - - it "should build a new HTTP POST request" do - Net::HTTP::Post.should_receive(:new).with("/", - { 'Accept' => 'application/json', "Content-Type" => 'application/json' } - ).and_return(@request_mock) - do_run_request(:POST, @data_mock) - end - - it "should build a new HTTP PUT request" do - Net::HTTP::Put.should_receive(:new).with("/", - { 'Accept' => 'application/json', "Content-Type" => 'application/json' } - ).and_return(@request_mock) - do_run_request(:PUT, @data_mock) - end - - it "should build a new HTTP DELETE request" do - Net::HTTP::Delete.should_receive(:new).with("/?foo=bar", - { 'Accept' => 'application/json' } - ).and_return(@request_mock) - do_run_request(:DELETE) - end - - describe "with HTTP Basic Authentication info in the URL" do - before(:each) do - @url_mock.stub!(:user).and_return('frodo') - @url_mock.stub!(:password).and_return('odorf') + + it "should return the body of the response on success" do + do_run_request.should eql("ninja") end - - %w(Get Post Put Delete).each do |verb| - it "should authenticate HTTP #{verb.upcase} requests" do - Net::HTTP::const_get(verb).stub!(:new).and_return(@request_mock) - @request_mock.should_receive(:basic_auth).with('frodo', 'odorf') - do_run_request(verb.upcase.to_sym) - end + + it "should inflate the body as to an object if JSON is returned" do + @http_response_mock.stub!(:[]).with('content-type').and_return("application/json") + JSON.should_receive(:parse).with("ninja").and_return(true) + do_run_request + end + + it "should call run_request again on a Redirect response" do + @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(false) + @http_response_mock.stub!(:kind_of?).with(Net::HTTPFound).and_return(true) + @http_response_mock.stub!(:[]).with('location').and_return(@url_mock.path) + lambda { do_run_request(method=:GET, data=false, limit=1) }.should raise_error(ArgumentError) end - end - it "should raise an error if the method is not GET/PUT/POST/DELETE" do - lambda { do_run_request(:MONKEY) }.should raise_error(ArgumentError) - end - - it "should run an http request" do - @http_mock.should_receive(:request).and_return(@http_response_mock) - do_run_request - end - - it "should return the body of the response on success" do - do_run_request.should eql("ninja") - end - - it "should inflate the body as to an object if JSON is returned" do - @http_response_mock.stub!(:[]).with('content-type').and_return("application/json") - JSON.should_receive(:parse).with("ninja").and_return(true) - do_run_request - end - - it "should call run_request again on a Redirect response" do - @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(false) - @http_response_mock.stub!(:kind_of?).with(Net::HTTPFound).and_return(true) - @http_response_mock.stub!(:[]).with('location').and_return(@url_mock.path) - lambda { do_run_request(method=:GET, data=false, limit=1) }.should raise_error(ArgumentError) - end + it "should call run_request again on a Permanent Redirect response" do + @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(false) + @http_response_mock.stub!(:kind_of?).with(Net::HTTPFound).and_return(false) + @http_response_mock.stub!(:kind_of?).with(Net::HTTPMovedPermanently).and_return(true) + @http_response_mock.stub!(:[]).with('location').and_return(@url_mock.path) + lambda { do_run_request(method=:GET, data=false, limit=1) }.should raise_error(ArgumentError) + end + + it "should raise an exception on an unsuccessful request" do + @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(false) + @http_response_mock.stub!(:kind_of?).with(Net::HTTPFound).and_return(false) + @http_response_mock.stub!(:kind_of?).with(Net::HTTPMovedPermanently).and_return(false) + @http_response_mock.should_receive(:error!) + do_run_request + end + + it "should build a new HTTP GET request without the application/json accept header for raw reqs" do + Net::HTTP::Get.should_receive(:new).with("/?foo=bar", {}).and_return(@request_mock) + do_run_request(:GET, false, 10, true) + end + + it "should create a tempfile for the output of a raw request" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + Tempfile.should_receive(:new).with("chef-rest").and_return(@tf_mock) + do_run_request(:GET, false, 10, true).should eql(@tf_mock) + end + + it "should read the body of the response in chunks on a raw request" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + @http_response_mock.should_receive(:read_body).and_return(true) + do_run_request(:GET, false, 10, true) + end + + it "should populate the tempfile with the value of the raw request" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + @http_response_mock.stub!(:read_body).and_yield("ninja") + @tf_mock.should_receive(:write, "ninja").once.and_return(true) + do_run_request(:GET, false, 10, true) + end + + it "should close the tempfile if we're doing a raw request" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + @tf_mock.should_receive(:close).once.and_return(true) + do_run_request(:GET, false, 10, true) + end + + it "should not raise a divide by zero exception if the size is 0" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "5" }) + @http_response_mock.stub!(:read_body).and_yield('') + lambda { do_run_request(:GET, false, 10, true) }.should_not raise_error(ZeroDivisionError) + end + + it "should not raise a divide by zero exception if the Content-Length is 0" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "0" }) + @http_response_mock.stub!(:read_body).and_yield("ninja") + lambda { do_run_request(:GET, false, 10, true) }.should_not raise_error(ZeroDivisionError) + end + + it "should call read_body without a block if the request is not raw" do + @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) + @http_response_mock.should_receive(:read_body) + do_run_request(:GET, false, 10, false) + end - it "should call run_request again on a Permanent Redirect response" do - @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(false) - @http_response_mock.stub!(:kind_of?).with(Net::HTTPFound).and_return(false) - @http_response_mock.stub!(:kind_of?).with(Net::HTTPMovedPermanently).and_return(true) - @http_response_mock.stub!(:[]).with('location').and_return(@url_mock.path) - lambda { do_run_request(method=:GET, data=false, limit=1) }.should raise_error(ArgumentError) - end - - it "should raise an exception on an unsuccessful request" do - @http_response_mock.stub!(:kind_of?).with(Net::HTTPSuccess).and_return(false) - @http_response_mock.stub!(:kind_of?).with(Net::HTTPFound).and_return(false) - @http_response_mock.stub!(:kind_of?).with(Net::HTTPMovedPermanently).and_return(false) - @http_response_mock.should_receive(:error!) - do_run_request - end - - it "should build a new HTTP GET request without the application/json accept header for raw reqs" do - Net::HTTP::Get.should_receive(:new).with("/?foo=bar", {}).and_return(@request_mock) - do_run_request(:GET, false, 10, true) - end - - it "should create a tempfile for the output of a raw request" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - Tempfile.should_receive(:new).with("chef-rest").and_return(@tf_mock) - do_run_request(:GET, false, 10, true).should eql(@tf_mock) - end - - it "should read the body of the response in chunks on a raw request" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @http_response_mock.should_receive(:read_body).and_return(true) - do_run_request(:GET, false, 10, true) - end - - it "should populate the tempfile with the value of the raw request" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @http_response_mock.stub!(:read_body).and_yield("ninja") - @tf_mock.should_receive(:write, "ninja").once.and_return(true) - do_run_request(:GET, false, 10, true) - end - - it "should close the tempfile if we're doing a raw request" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @tf_mock.should_receive(:close).once.and_return(true) - do_run_request(:GET, false, 10, true) - end - - it "should not raise a divide by zero exception if the size is 0" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "5" }) - @http_response_mock.stub!(:read_body).and_yield('') - lambda { do_run_request(:GET, false, 10, true) }.should_not raise_error(ZeroDivisionError) - end - - it "should not raise a divide by zero exception if the Content-Length is 0" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "0" }) - @http_response_mock.stub!(:read_body).and_yield("ninja") - lambda { do_run_request(:GET, false, 10, true) }.should_not raise_error(ZeroDivisionError) - end - - it "should call read_body without a block if the request is not raw" do - @http_mock.stub!(:request).and_yield(@http_response_mock).and_return(@http_response_mock) - @http_response_mock.should_receive(:read_body) - do_run_request(:GET, false, 10, false) end end + chef/spec/unit/rest_spec.rb @@ -147,7 +147,7 @@ describe Chef::RunList do Chef::Role.stub!(:from_disk).and_return(@role) Chef::Role.stub!(:load).and_return(@role) - @rest = mock("Chef::REST", { :get_rest => @role }) + @rest = mock("Chef::REST", { :get_rest => @role, :url => "/" }) Chef::REST.stub!(:new).and_return(@rest) @run_list << "role[stubby]" @@ -175,7 +175,7 @@ describe Chef::RunList do describe "from couchdb" do it "should load the role from couchdb" do - Chef::Role.should_receive(:load).with("stubby") + Chef::Role.should_receive(:cdb_load).and_return(@role) @run_list.expand("couchdb") end end chef/spec/unit/run_list_spec.rb @@ -8,7 +8,7 @@ task :default => :spec desc "Run all specs in spec directory" Spec::Rake::SpecTask.new(:spec) do |t| - t.spec_opts = ['--options', "\"#{CHEF_ROOT}/spec/spec.opts\""] + t.spec_opts = ['--format', 'specdoc', '--options', "\"#{CHEF_ROOT}/spec/spec.opts\""] t.spec_files = FileList['spec/**/*_spec.rb'] end chef/tasks/rspec.rb @@ -1,22 +1,46 @@ default: -f pretty features -r features/steps -r features/support -api: --tags api --format pretty -r features/steps -r features/support features -api_roles: --tags roles --format pretty -r features/steps -r features/support features +api: --tags @api --format pretty -r features/steps -r features/support features +api_cookbooks: --tags @api,@cookbooks --format pretty -r features/steps -r features/support features +api_clients: --tags @api_clients --format pretty -r features/steps -r features/support features +api_clients_create: --tags clients_create --format pretty -r features/steps -r features/support features +api_clients_delete: --tags clients_delete --format pretty -r features/steps -r features/support features +api_clients_list: --tags clients_list --format pretty -r features/steps -r features/support features +api_clients_show: --tags clients_show --format pretty -r features/steps -r features/support features +api_clients_update: --tags clients_update --format pretty -r features/steps -r features/support features +api_roles: --tags @api_roles --format pretty -r features/steps -r features/support features api_roles_create: --tags roles_create --format pretty -r features/steps -r features/support features api_roles_delete: --tags roles_delete --format pretty -r features/steps -r features/support features api_roles_list: --tags roles_list --format pretty -r features/steps -r features/support features api_roles_show: --tags roles_show --format pretty -r features/steps -r features/support features api_roles_update: --tags roles_update --format pretty -r features/steps -r features/support features -api_nodes: --tags nodes --format pretty -r features/steps -r features/support features +api_nodes: --tags @api_nodes --format pretty -r features/steps -r features/support features +api_nodes_sync: --tags @cookbook_sync --format pretty -r features/steps -r features/support features api_nodes_create: --tags nodes_create --format pretty -r features/steps -r features/support features api_nodes_delete: --tags nodes_delete --format pretty -r features/steps -r features/support features api_nodes_list: --tags nodes_list --format pretty -r features/steps -r features/support features api_nodes_show: --tags nodes_show --format pretty -r features/steps -r features/support features api_nodes_update: --tags nodes_update --format pretty -r features/steps -r features/support features -client: --tags client --format pretty -r features/steps -r features/support features +api_data: --tags @api_data --format pretty -r features/steps -r features/support features +api_data_delete: --tags @api_data_delete --format pretty -r features/steps -r features/support features +api_data_item: --tags @api_data_item --format pretty -r features/steps -r features/support features +api_search: --tags @api_search --format pretty -r features/steps -r features/support features +api_search_list: --tags @api_search_list --format pretty -r features/steps -r features/support features +api_search_show: --tags @api_search_show --format pretty -r features/steps -r features/support features +client: --tags @client --format pretty -r features/steps -r features/support features client_roles: --tags client_roles --format pretty -r features/steps -r features/support features -search: --tags search --format pretty -r features/steps -r features/support features -language: --tags language --format pretty -r features/steps -r features/support features +search: --tags @search --format pretty -r features/steps -r features/support features +provider: --tags @provider --format pretty -r features/steps -r features/support features +provider_directory: --tags @provider_directory --format pretty -r features/steps -r features/support features +provider_deploy: --tags @provider_deploy --format pretty -r features/steps -r features/support features +provider_execute: --tags @provider_execute --format pretty -r features/steps -r features/support features +provider_file: --tags @provider_file --format pretty -r features/steps -r features/support features +provider_template: --tags template --format pretty -r features/steps -r features/support features +provider_remote_file: --tags @remote_file --format pretty -r features/steps -r features/support features +provider_package_macports: --tags @macports --format pretty -r features/steps -r features/support features +language: --tags @language --format pretty -r features/steps -r features/support features +client_run_interval: --tags client_run_interval --format pretty -r features/steps -r features/support features recipe_inclusion: --tags recipe_inclusion --format pretty -r features/steps -r features/support features +cookbooks: --tags @cookbooks --format pretty -r features/steps -r features/support features provider_remote_file: --tags provider,remote_file --format pretty -r features/steps -r features/support features provider_git: --tags provider,git --format pretty -r features/steps -r features/support features provider_template: --tags template --format pretty -r features/steps -r features/support features cucumber.yml @@ -1,4 +1,4 @@ -@api @nodes @nodes_create +@api @api_nodes @nodes_create Feature: Create a node via the REST API In order to create nodes programatically As a Devleoper @@ -7,19 +7,19 @@ Feature: Create a node via the REST API Scenario: Create a new node Given a 'registration' named 'bobo' exists And a 'node' named 'webserver' - When I authenticate as 'bobo' - And I 'POST' the 'node' to the path '/nodes' + When I 'POST' the 'node' to the path '/nodes' And the inflated responses key 'uri' should match '^http://.+/nodes/webserver$' Scenario: Create a node that already exists Given a 'registration' named 'bobo' exists And an 'node' named 'webserver' - When I authenticate as 'bobo' - And I 'POST' the 'node' to the path '/nodes' + When I 'POST' the 'node' to the path '/nodes' And I 'POST' the 'node' to the path '/nodes' Then I should get a '403 "Forbidden"' exception - - Scenario: Create a new node without authenticating - Given a 'node' named 'webserver' - When I 'POST' the 'node' to the path '/nodes' + + Scenario: Create a node with a wrong private key + Given a 'registration' named 'bobo' exists + And an 'node' named 'webserver' + When I 'POST' the 'node' to the path '/nodes' using a wrong private key Then I should get a '401 "Unauthorized"' exception + features/api/nodes/create_node_api.feature @@ -1,4 +1,4 @@ -@api @nodes @nodes_delete +@api @api_nodes @nodes_delete Feature: Delete a node via the REST API In order to remove a node As a Developer @@ -7,19 +7,24 @@ Feature: Delete a node via the REST API Scenario: Delete a node Given a 'registration' named 'bobo' exists And a 'node' named 'webserver' exists - When I authenticate as 'bobo' - And I 'DELETE' the path '/nodes/webserver' + When I 'DELETE' the path '/nodes/webserver' Then the inflated response should respond to 'name' with 'webserver' Scenario: Delete a node that does not exist Given a 'registration' named 'bobo' exists And there are no nodes - When I authenticate as 'bobo' When I 'DELETE' the path '/nodes/webserver' Then I should get a '404 "Not Found"' exception - Scenario: Delete a node without authenticating - Given a 'node' named 'webserver' + Scenario: Delete a node with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'node' named 'webserver' exists + When I 'DELETE' the path '/nodes/webserver' using a wrong private key + Then I should get a '401 "Unauthorized"' exception + + Scenario: Delete a node as a when I am not an admin + Given a 'registration' named 'not_admin' exists + And a 'node' named 'webserver' exists When I 'DELETE' the path '/nodes/webserver' Then I should get a '401 "Unauthorized"' exception features/api/nodes/delete_node_api.feature @@ -1,4 +1,4 @@ -@api @nodes @nodes_list +@api @api_nodes @nodes_list Feature: List nodes via the REST API In order to know what nodes exists programatically As a Developer @@ -7,28 +7,26 @@ Feature: List nodes via the REST API Scenario: List nodes when none have been created Given a 'registration' named 'bobo' exists And there are no nodes - When I authenticate as 'bobo' - And I 'GET' the path '/nodes' - Then the inflated response should be an empty array + When I 'GET' the path '/nodes' + Then the inflated response should be an empty hash Scenario: List nodes when one has been created Given a 'registration' named 'bobo' exists Given a 'node' named 'webserver' exists - When I authenticate as 'bobo' - And I 'GET' the path '/nodes' - Then the inflated response should include '^http://.+/nodes/webserver$' - + When I 'GET' the path '/nodes' + Then the inflated responses key 'webserver' should match '^http://.+/nodes/webserver$' + Scenario: List nodes when two have been created Given a 'registration' named 'bobo' exists And a 'node' named 'webserver' exists And a 'node' named 'dbserver' exists - When I authenticate as 'bobo' - And I 'GET' the path '/nodes' + When I 'GET' the path '/nodes' Then the inflated response should be '2' items long - And the inflated response should include '^http://.+/nodes/webserver$' - And the inflated response should include '^http://.+/nodes/dbserver$' + Then the inflated responses key 'webserver' should match '^http://.+/nodes/webserver$' + Then the inflated responses key 'dbserver' should match '^http://.+/nodes/dbserver$' - Scenario: List nodes when you are not authenticated - When I 'GET' the path '/nodes' + Scenario: List nodes none have been created with a wrong private key + Given a 'registration' named 'bobo' exists + And there are no cookbooks + When I 'GET' the path '/nodes' using a wrong private key Then I should get a '401 "Unauthorized"' exception - features/api/nodes/list_nodes_api.feature @@ -1,4 +1,4 @@ -@api @nodes @nodes_show +@api @api_nodes @nodes_show Feature: Show a node via the REST API In order to know what the details are for a node As a Developer @@ -7,19 +7,18 @@ Feature: Show a node via the REST API Scenario: Show a node Given a 'registration' named 'bobo' exists And a 'node' named 'webserver' exists - When I authenticate as 'bobo' - And I 'GET' the path '/nodes/webserver' + When I 'GET' the path '/nodes/webserver' Then the inflated response should respond to 'name' with 'webserver' Scenario: Show a missing node Given a 'registration' named 'bobo' exists And there are no nodes - When I authenticate as 'bobo' - And I 'GET' the path '/nodes/bobo' + When I 'GET' the path '/nodes/bobo' Then I should get a '404 "Not Found"' exception - Scenario: Show a node without authenticating - Given a 'node' named 'webserver' exists - And I 'GET' the path '/nodes/webserver' + Scenario: Show a node with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'node' named 'webserver' exists + When I 'GET' the path '/nodes/webserver' using a wrong private key Then I should get a '401 "Unauthorized"' exception features/api/nodes/show_node_api.feature @@ -1,4 +1,4 @@ -@api @nodes @nodes_update +@api @api_nodes @nodes_update Feature: Update a node In order to keep my node data up-to-date As a Developer @@ -8,7 +8,6 @@ Feature: Update a node Given a 'registration' named 'bobo' exists And a 'node' named 'webserver' exists And sending the method '<method>' to the 'node' with '<updated_value>' - When I authenticate as 'bobo' When I 'PUT' the 'node' to the path '/nodes/webserver' Then the inflated response should respond to '<method>' with '<updated_value>' When I 'GET' the path '/nodes/webserver' @@ -19,9 +18,18 @@ Feature: Update a node | run_list | [ "recipe[one]", "recipe[two]" ] | | snakes | really arent so bad | - Scenario: Update a node without authenticating - Given a 'node' named 'webserver' - And sending the method 'snakes' to the 'node' with 'night train' - When I 'PUT' the 'node' to the path '/nodes/webserver' + + Scenario: Update a node with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'node' named 'webserver' exists + And sending the method 'run_list' to the 'node' with '[ "recipe[one]", "recipe[two]" ]' + When I 'PUT' the 'node' to the path '/nodes/webserver' using a wrong private key + Then I should get a '401 "Unauthorized"' exception + + Scenario: Update a node when I am not an admin + Given a 'registration' named 'not_admin' exists + And a 'node' named 'webserver' exists + And sending the method 'run_list' to the 'node' with '[ "recipe[one]", "recipe[two]" ]' + When I 'PUT' the 'node' to the path '/nodes/webserver' Then I should get a '401 "Unauthorized"' exception features/api/nodes/update_node_api.feature @@ -1,4 +1,4 @@ -@api @roles @roles_create +@api @api_roles @roles_create Feature: Create a role via the REST API In order to create roles programatically As a Devleoper @@ -7,20 +7,25 @@ Feature: Create a role via the REST API Scenario: Create a new role Given a 'registration' named 'bobo' exists And a 'role' named 'webserver' - When I authenticate as 'bobo' - And I 'POST' the 'role' to the path '/roles' + When I 'POST' the 'role' to the path '/roles' And the inflated responses key 'uri' should match '^http://.+/roles/webserver$' Scenario: Create a role that already exists Given a 'registration' named 'bobo' exists And an 'role' named 'webserver' - When I authenticate as 'bobo' - And I 'POST' the 'role' to the path '/roles' + When I 'POST' the 'role' to the path '/roles' And I 'POST' the 'role' to the path '/roles' Then I should get a '403 "Forbidden"' exception - Scenario: Create a new role without authenticating - Given a 'role' named 'webserver' + Scenario: Create a new role with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'role' named 'webserver' + When I 'POST' the 'role' to the path '/roles' using a wrong private key + Then I should get a '401 "Unauthorized"' exception + + Scenario: Create a new role as a non-admin + Given a 'registration' named 'not_admin' exists + And a 'role' named 'webserver' When I 'POST' the 'role' to the path '/roles' Then I should get a '401 "Unauthorized"' exception features/api/roles/create_role_api.feature @@ -1,4 +1,4 @@ -@api @roles @roles_delete +@api @api_roles @roles_delete Feature: Delete a Role via the REST API In order to remove a role As a Developer @@ -7,19 +7,24 @@ Feature: Delete a Role via the REST API Scenario: Delete a Role Given a 'registration' named 'bobo' exists And a 'role' named 'webserver' exists - When I authenticate as 'bobo' - And I 'DELETE' the path '/roles/webserver' + When I 'DELETE' the path '/roles/webserver' Then the inflated response should respond to 'name' with 'webserver' Scenario: Delete a Role that does not exist Given a 'registration' named 'bobo' exists And there are no roles - When I authenticate as 'bobo' When I 'DELETE' the path '/roles/webserver' Then I should get a '404 "Not Found"' exception + + Scenario: Delete a Role with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'role' named 'webserver' exists + When I 'DELETE' the path '/roles/webserver' using a wrong private key + Then I should get a '401 "Unauthorized"' exception - Scenario: Delete a Role without authenticating - Given a 'role' named 'webserver' + Scenario: Delete a Role as a non-admin + Given a 'registration' named 'not_admin' exists + And a 'role' named 'webserver' exists When I 'DELETE' the path '/roles/webserver' Then I should get a '401 "Unauthorized"' exception features/api/roles/delete_role_api.feature @@ -1,4 +1,4 @@ -@api @roles @roles_list +@api @api_roles @roles_list Feature: List roles via the REST API In order to know what roles exists programatically As a Developer @@ -6,30 +6,29 @@ Feature: List roles via the REST API Scenario: List roles when none have been created Given a 'registration' named 'bobo' exists - And there are no roles - When I authenticate as 'bobo' - And I 'GET' the path '/roles' - Then the inflated response should be an empty array + And there are no roles + When I 'GET' the path '/roles' + Then the inflated response should be '1' items long Scenario: List roles when one has been created Given a 'registration' named 'bobo' exists Given a 'role' named 'webserver' exists - When I authenticate as 'bobo' - And I 'GET' the path '/roles' - Then the inflated response should include '^http://.+/roles/webserver$' + When I 'GET' the path '/roles' + Then the inflated responses key 'webserver' should match '^http://.+/roles/webserver$' Scenario: List roles when two have been created Given a 'registration' named 'bobo' exists And a 'role' named 'webserver' exists And a 'role' named 'db' exists - When I authenticate as 'bobo' - And I 'GET' the path '/roles' + When I 'GET' the path '/roles' Then the inflated response should be '3' items long - And the inflated response should include '^http://.+/roles/role_test$' - And the inflated response should include '^http://.+/roles/webserver$' - And the inflated response should include '^http://.+/roles/db$' + And the inflated responses key 'role_test' should match '^http://.+/roles/role_test$' + And the inflated responses key 'webserver' should match '^http://.+/roles/webserver$' + And the inflated responses key 'db' should match '^http://.+/roles/db$' - Scenario: List roles when you are not authenticated - When I 'GET' the path '/roles' + Scenario: List roles when none have been created with a wrong private key + Given a 'registration' named 'bobo' exists + And there are no roles + When I 'GET' the path '/roles' using a wrong private key Then I should get a '401 "Unauthorized"' exception features/api/roles/list_roles_api.feature @@ -1,4 +1,4 @@ -@api @roles @roles_show +@api @api_roles @roles_show Feature: Show a role via the REST API In order to know what the details are for a Role As a Developer @@ -7,20 +7,18 @@ Feature: Show a role via the REST API Scenario: Show a role Given a 'registration' named 'bobo' exists And a 'role' named 'webserver' exists - When I authenticate as 'bobo' - And I 'GET' the path '/roles/webserver' + When I 'GET' the path '/roles/webserver' Then the inflated response should respond to 'name' with 'webserver' Scenario: Show a missing role Given a 'registration' named 'bobo' exists And there are no roles - When I authenticate as 'bobo' - And I 'GET' the path '/roles/bobo' + When I 'GET' the path '/roles/bobo' Then I should get a '404 "Not Found"' exception - Scenario: Show a role without authenticating - Given a 'role' named 'webserver' exists - And I 'GET' the path '/roles/webserver' + Scenario: Show a role with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'role' named 'webserver' exists + When I 'GET' the path '/roles/webserver' using a wrong private key Then I should get a '401 "Unauthorized"' exception - features/api/roles/show_roles_api.feature @@ -1,4 +1,4 @@ -@api @roles @roles_update +@api @api_roles @roles_update Feature: Update a role In order to keep my role data up-to-date As a Developer @@ -8,7 +8,6 @@ Feature: Update a role Given a 'registration' named 'bobo' exists And a 'role' named 'webserver' exists And sending the method '<method>' to the 'role' with '<updated_value>' - When I authenticate as 'bobo' When I 'PUT' the 'role' to the path '/roles/webserver' Then the inflated response should respond to '<method>' with '<updated_value>' When I 'GET' the path '/roles/webserver' @@ -21,9 +20,17 @@ Feature: Update a role | default_attributes | { "a": "d" } | | override_attributes | { "c": "e" } | - Scenario: Update a role without authenticating - Given a 'role' named 'webserver' - And sending the method 'description' to the 'role' with 'Is easy' - When I 'PUT' the 'role' to the path '/roles/webserver' + Scenario: Update a role with a wrong private key + Given a 'registration' named 'bobo' exists + And a 'role' named 'webserver' exists + And sending the method 'description' to the 'role' with 'gorilla' + When I 'PUT' the 'role' to the path '/roles/webserver' using a wrong private key + Then I should get a '401 "Unauthorized"' exception + + Scenario: Update a role as a non-admin user + Given a 'registration' named 'not_admin' exists + And a 'role' named 'webserver' exists + And sending the method 'description' to the 'role' with 'gorilla' + When I 'PUT' the 'role' to the path '/roles/webserver' using a wrong private key Then I should get a '401 "Unauthorized"' exception features/api/roles/update_roles_api.feature @@ -1,4 +1,4 @@ -@client +@client @client_run_interval Feature: Run chef-client at periodic intervals In order to ensure a system is always correctly configured As an Administrator features/chef-client/run_interval.feature @@ -6,9 +6,15 @@ log_location STDOUT file_cache_path File.join(tmpdir, "cache") ssl_verify_mode :verify_none registration_url "http://127.0.0.1:4000" -openid_url "http://127.0.0.1:4001" +openid_url "http://127.0.0.1:4000" template_url "http://127.0.0.1:4000" remotefile_url "http://127.0.0.1:4000" search_url "http://127.0.0.1:4000" -role_url "http://127.0.0.1:4000" -couchdb_database 'chef_integration' +role_url "http://127.0.0.1:4000" +client_url "http://127.0.0.1:4000" +chef_server_url "http://127.0.0.1:4000" +validation_client_name "validator" +systmpdir = File.expand_path(File.join(Dir.tmpdir, "chef_integration")) +validation_key File.join(systmpdir, "validation.pem") +client_key File.join(systmpdir, "client.pem") + features/data/config/client.rb @@ -6,17 +6,33 @@ log_location STDOUT file_cache_path File.join(tmpdir, "cache") ssl_verify_mode :verify_none registration_url "http://127.0.0.1:4000" -openid_url "http://127.0.0.1:4001" +openid_url "http://127.0.0.1:4000" template_url "http://127.0.0.1:4000" remotefile_url "http://127.0.0.1:4000" search_url "http://127.0.0.1:4000" -role_url "http://127.0.0.1:4000" +role_url "http://127.0.0.1:4000" +chef_server_url "http://127.0.0.1:4000" +client_url "http://127.0.0.1:4000" cookbook_path File.join(supportdir, "cookbooks") openid_store_path File.join(tmpdir, "openid", "store") openid_cstore_path File.join(tmpdir, "openid", "cstore") search_index_path File.join(tmpdir, "search_index") role_path File.join(supportdir, "roles") -validation_token 'ceelo' +signing_ca_path File.join(tmpdir, "ca") couchdb_database 'chef_integration' +systmpdir = File.expand_path(File.join(Dir.tmpdir, "chef_integration")) + +validation_client_name "validator" +validation_key File.join(systmpdir, "validation.pem") +client_key File.join(systmpdir, "client.pem") +web_ui_client_name "chef-webui" +web_ui_key File.join(systmpdir, "webui.pem") + +solr_jetty_path File.join(supportdir, "solr", "jetty") +solr_heap_size "250M" +solr_data_path File.join(supportdir, "solr", "data") +solr_home_path File.join(supportdir, "solr", "home") +solr_heap_size "256M" + Chef::Log::Formatter.show_time = true features/data/config/server.rb @@ -19,7 +19,7 @@ directory node[:int][:tmpdir] do owner "root" - mode 1777 + mode "1777" action :create end features/data/cookbooks/integration_setup/recipes/default.rb @@ -17,11 +17,12 @@ # limitations under the License. # -node.save -sleep 5 -search(:node, "*") do |entry| - Chef::Log.error(entry.inspect) - entry["search_files"].each do |filename| - file "#{node[:tmpdir]}/#{filename}" - end +# We have to sleep at least 10 seconds to confirm that the data has made it +# into the index. We can only rely on this because we are in a test environment +# in real-land Chef, the index is only eventually consistent.. and may take a +# variable amount of time. +sleep 10 +search(:users, "*:*") do |entry| + file "#{node[:tmpdir]}/#{entry["id"]}" end + features/data/cookbooks/search/recipes/search_data.rb @@ -14,4 +14,4 @@ "ossining": "whatever", "snakes": "on a plane" } -} \ No newline at end of file +} features/data/roles/role_test.json @@ -1,3 +1,4 @@ +@language Feature: Delayed Notifications In order to not impact the system we are configuring unduly As a developer features/language/delayed_notifications.feature @@ -1,4 +1,4 @@ -@provider @git @deploy +@provider @git @deploy @provider_deploy Feature: Deploy In order to repeatably and reliably deploy web apps from a source repository from the comfort of chef features/provider/deploy/deploy.feature @@ -1,3 +1,4 @@ +@provider @provider_directory Feature: Create Directories In order to save time As a Developer features/provider/directory/create_directories.feature @@ -1,3 +1,4 @@ +@provider @provider_directory Feature: Delete Directories In order to save time As a Developer features/provider/directory/delete_directories.feature @@ -1,3 +1,4 @@ +@provider @provider_execute Feature: Run Commands In order to utilize the plethora of useful command line utilities As a Developer features/provider/execute/run_commands.feature @@ -1,3 +1,4 @@ +@provider @provider_file Feature: Manage Files In order to save time As a Developer features/provider/file/manage_files.feature @@ -4,11 +4,25 @@ Feature: Search Data As a Developer I want to search the data - Scenario: Search the node index + Scenario: Search the user index Given a validated node And it includes the recipe 'search::search_data' + And a 'data_bag' named 'users' exists + And a 'data_bag_item' named 'francis' exists + And a 'data_bag_item' named 'axl_rose' exists When I run the chef-client Then the run should exit '0' - And a file named 'search_one.txt' should exist - And a file named 'search_two.txt' should exist + And a file named 'francis' should exist + And a file named 'axl_rose' should exist + + Scenario: Search the user index without a block + Given a validated node + And it includes the recipe 'search::search_data_noblock' + And a 'data_bag' named 'users' exists + And a 'data_bag_item' named 'francis' exists + And a 'data_bag_item' named 'axl_rose' exists + When I run the chef-client + Then the run should exit '0' + And a file named 'francis' should exist + And a file named 'axl_rose' should exist features/search/search_data.feature @@ -1,5 +1,6 @@ # # Author:: Adam Jacob (<adam@opscode.com>) +# Author:: Chris Walters (<cw@opscode.com>) # Copyright:: Copyright (c) 2008 Opscode, Inc. # License:: Apache License, Version 2.0 # @@ -51,3 +52,4 @@ When /^I run the rake task to generate cookbook metadata$/ do end end end + features/steps/cookbook_steps.rb @@ -54,6 +54,6 @@ end Then /^the second chef run should have skipped deployment$/ do expected_deploy = "#{tmpdir}/deploy/releases/62c9979f6694612d9659259f8a68d71048ae9a5b" - Then "'stdout' should have 'INFO: Already deployed app at #{expected_deploy}, skipping. Use action :force_deploy to force.'" + Then "'stdout' should not have 'INFO: Already deployed app at #{expected_deploy}. Rolling back to it - use action :force_deploy to re-checkout this revision.'" end features/steps/deploy_steps.rb @@ -1,14 +1,74 @@ +require 'ostruct' + Before do @fixtures = { + 'client' => { + 'isis' => Proc.new do + c = Chef::ApiClient.new + c.name "isis" + c.create_keys + c + end, + 'isis_update' => { + 'name' => 'isis', + 'private_key' => true + }, + 'neurosis' => Proc.new do + c = Chef::ApiClient.new + c.name "neurosis" + c.create_keys + c + end, + 'adminmonkey' => Proc.new do + c = Chef::ApiClient.new + c.name "adminmonkey" + c.admin true + c.create_keys + c + end + }, + 'signing_caller' =>{ + :user_id=>'bobo', :secret_key => "/tmp/poop.pem" + }, 'registration' => { 'bobo' => Proc.new do - r = Chef::OpenIDRegistration.new - r.name = "bobo" - r.set_password('tclown') - r.validated = true - r.admin = true - r + OpenStruct.new({ :save => true }) + end, + 'not_admin' => Proc.new do + OpenStruct.new({ :save => true }) + end + }, + 'data_bag' => { + 'users' => Proc.new do + b = Chef::DataBag.new + b.name "users" + b + end, + 'rubies' => Proc.new do + b = Chef::DataBag.new + b.name "rubies" + b + end + }, + 'data_bag_item' => { + 'francis' => Proc.new do + i = Chef::DataBagItem.new + i.data_bag "users" + i.raw_data = { "id" => "francis" } + i + end, + 'francis_extra' => Proc.new do + i = Chef::DataBagItem.new + i.data_bag "users" + i.raw_data = { "id" => "francis", "extra" => "majority" } + i + end, + 'axl_rose' => Proc.new do + i = Chef::DataBagItem.new + i.data_bag "users" + i.raw_data = { "id" => "axl_rose" } + i end }, 'role' => { @@ -46,12 +106,29 @@ Before do n.run_list << "oracle" n.just "kidding - who uses oracle?" n + end, + 'sync' => Proc.new do + n = Chef::Node.new + n.name 'sync' + n.run_list << "node_cookbook_sync" + n end } } @stash = {} end +def sign_request(http_method, private_key, user_id, body = "") + timestamp = Time.now.utc.iso8601 + sign_obj = Mixlib::Auth::SignedHeaderAuth.signing_object( + :http_method=>http_method, + :body=>body, + :user_id=>user_id, + :timestamp=>timestamp) + signed = sign_obj.sign(private_key).merge({:host => "localhost"}) + signed.inject({}){|memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1];memo} +end + def get_fixture(stash_name, stash_key) fixy = @fixtures[stash_name][stash_key] if fixy.kind_of?(Proc) @@ -62,20 +139,48 @@ def get_fixture(stash_name, stash_key) end Given /^an? '(.+)' named '(.+)'$/ do |stash_name, stash_key| - @stash[stash_name] = get_fixture(stash_name, stash_key) + # BUGBUG: I need to reference fixtures individually, but the fixtures, as written, store under the type, not the fixture's identifier and I don't currently have time to re-write the tests + + key = case stash_name + when 'file','hash' + stash_key + else + stash_name + end + @stash[key] = get_fixture(stash_name, stash_key) end -Given /^an? '(.+)' named '(.+)' exists$/ do |stash_name, stash_key| +Given /^an? '(.+)' named '(.+)' exists$/ do |stash_name, stash_key| @stash[stash_name] = get_fixture(stash_name, stash_key) - if @stash[stash_name].respond_to?(:save) - @stash[stash_name].save - else - request("/#{stash_name.pluralize}", { - :method => "POST", - "HTTP_ACCEPT" => 'application/json', - "CONTENT_TYPE" => 'application/json', - :input => @stash[stash_name].to_json - }) + + if stash_name == 'registration' + if stash_key == "bobo" + r = Chef::REST.new(Chef::Config[:registration_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]) + r.register("bobo", "#{tmpdir}/bobo.pem") + c = Chef::ApiClient.cdb_load("bobo") + c.admin(true) + c.cdb_save + @rest = Chef::REST.new(Chef::Config[:registration_url], 'bobo', "#{tmpdir}/bobo.pem") + elsif stash_key == "not_admin" + r = Chef::REST.new(Chef::Config[:registration_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]) + r.register("not_admin", "#{tmpdir}/not_admin.pem") + c = Chef::ApiClient.cdb_load("not_admin") + c.cdb_save + @rest = Chef::REST.new(Chef::Config[:registration_url], 'not_admin', "#{tmpdir}/not_admin.pem") + end + else + if @stash[stash_name].respond_to?(:cdb_save) + @stash[stash_name].cdb_save + elsif @stash[stash_name].respond_to?(:save)#stash_name == "registration" + @stash[stash_name].save + else + request("#{stash_name.pluralize}", { + :method => "POST", + "HTTP_ACCEPT" => 'application/json', + "CONTENT_TYPE" => 'application/json', + :input => @stash[stash_name].to_json + }.merge(sign_request("POST", OpenSSL::PKey::RSA.new(IO.read("#{tmpdir}/client.pem")), "bobo"))) + end end end @@ -93,8 +198,8 @@ Given /^removing the '(.+)' field '(.+)'$/ do |stash_name, key| end Given /^there are no (.+)$/ do |stash_name| - case stash_name - when 'roles' - Chef::Role.list(true).each { |r| r.destroy } - end +end + +Given /^I wait for '(\d+)' seconds$/ do |time| + sleep time.to_i end features/steps/fixture_steps.rb @@ -20,9 +20,8 @@ # Given ### Given /^a validated node$/ do - client.validation_token = Chef::Config[:validation_token] = 'ceelo' + client.determine_node_name client.register - client.authenticate client.build_node client.node.recipes << "integration_setup" end features/steps/node_steps.rb @@ -1,21 +1,55 @@ -When /^I '(.+)' the path '(.+)'$/ do |http_method, request_uri| +When /^I '([^']*)' (?:to )?the path '([^']*)'$/ do |http_method, request_uri| begin self.response = rest.send("#{http_method}_rest".downcase.to_sym, request_uri) - self.inflated_response = self.response + self.inflated_response = self.response rescue + Chef::Log.debug("Caught exception in request: #{$!.message}") self.exception = $! end end +When /^I '([^']*)' to the path '(.+)'$/ do |http_method, request_uri| + When "I '#{http_method}' the path '#{request_uri}'" +end + +When /^I '(.+)' the path '(.+)' using a wrong private key$/ do |http_method, request_uri| + key = OpenSSL::PKey::RSA.generate(2048) + File.open(File.join(tmpdir, 'false_key.pem'), "w") { |f| f.print key } + @rest = Chef::REST.new(Chef::Config[:chef_server_url], 'snakebite' , File.join(tmpdir, 'false_key.pem')) + + When "I '#{http_method}' the path '#{request_uri}'" +end + When /^I '(.+)' the '(.+)' to the path '(.+)'$/ do |http_method, stash_key, request_uri| begin - self.response = rest.send("#{http_method}_rest".downcase.to_sym, request_uri, stash[stash_key]) + self.response = rest.send("#{http_method.to_s.downcase}_rest".downcase.to_sym, request_uri, stash[stash_key]) self.inflated_response = response rescue self.exception = $! end end +When /^I '(.+)' the '(.+)' to the path '(.+)' using a wrong private key$/ do |http_method, stash_key, request_uri| + key = OpenSSL::PKey::RSA.generate(2048) + File.open(File.join(tmpdir, 'false_key.pem'), "w") { |f| f.print key } + @rest = Chef::REST.new(Chef::Config[:chef_server_url], 'snakebite' , File.join(tmpdir, 'false_key.pem')) + + When "I '#{http_method}' the '#{stash_key}' to the path '#{request_uri}'" +end + +When /^I delete local private key/ do + Chef::FileCache.delete("private_key.pem") +end + +When /^I register '(.+)'$/ do |user| + begin + rest = Chef::REST.new(Chef::Config[:registration_url]) + rest.register("bobo") + rescue + self.exception = $! + end +end + When /^I authenticate as '(.+)'$/ do |reg| begin rest.authenticate(reg, 'tclown') @@ -24,3 +58,59 @@ When /^I authenticate as '(.+)'$/ do |reg| end end + + + +# When /^I '(.+)' the path '(.+)'$/ do |http_method, request_uri| +# begin +# #if http_method.downcase == 'get' +# # self.response = @rest.get_rest(request_uri) +# #else +# #puts "test test test \n\n\n\n\n\n\n" +# @response = @rest.send("#{http_method}_rest".downcase.to_sym, request_uri) +# #end +# puts "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" +# puts @response +# puts @response['content-type'] +# #puts self.response +# #puts self.response.inspect +# #self.inflated_response = self.response +# @inflated_response = @response#JSON.parse(response.body.to_s) +# puts "~~~~~~~~INFLATED RESPONSE~~~~~~~~~~~~" +# puts @inflated_response +# rescue +# self.exception = $! +# end +# end +# +# When /^I '(.+)' the '(.+)' to the path '(.+)'$/ do |http_method, stash_key, request_uri| +# begin +# #if http_method.downcase == 'post' +# # puts "post request" +# # self.response = @rest.post_rest(request_uri, @stash[stash_key]) +# # puts self.response +# #else +# puts "This is the request -- @stash[stash_key]:" +# puts @stash[stash_key].to_s +# @response = @rest.send("#{http_method}_rest".downcase.to_sym, request_uri, @stash[stash_key]) +# #end +# puts "This is the response:" +# #puts self.response.body.to_s +# puts @response +# #self.inflated_response = response +# @inflated_response = @response#JSON.parse(self.response.body.to_s) +# puts "~~~~~~~~INFLATED RESPONSE~~~~~~~~~~~~" +# puts @inflated_response +# rescue +# self.exception = $! +# end +# end +# +# When /^I authenticate as '(.+)'$/ do |reg| +# begin +# rest.authenticate(reg, 'tclown') +# rescue +# self.exception = $! +# end +# end +# features/steps/request_steps.rb @@ -3,70 +3,129 @@ Then /^I should get a '(.+)' exception$/ do |exception| end Then /^the response code should be '(.+)'$/ do |response_code| - response.status.should == response_code.to_i + self.response.status.should == response_code.to_i +end + +Then /^the inflated responses key '(.+)' should be the integer '(\d+)'$/ do |key, int| + inflated_response[key].should == int.to_i end Then /^the inflated responses key '(.+)' should match '(.+)'$/ do |key, regex| - inflated_response[key].should =~ /#{regex}/ + puts self.inflated_response.inspect if ENV['DEBUG'] + self.inflated_response[key].should =~ /#{regex}/m +end + +Then /^the inflated responses key '(.+)' should be literally '(.+)'$/ do |key, literal| + puts self.inflated_response.inspect if ENV['DEBUG'] + to_check = case literal + when "true" + true + when "false" + false + end + + self.inflated_response[key].should == to_check +end + +Then /^the inflated response should match '(.+)' as json$/ do |regex| + puts self.inflated_response.inspect if ENV["DEBUG"] + self.inflated_response.to_json.should =~ /#{regex}/m +end + +Then /^the inflated responses key '(.+)' should match '(.+)' as json$/ do |key, regex| + puts self.inflated_response.inspect if ENV["DEBUG"] + self.inflated_response[key].to_json.should =~ /#{regex}/m +end + +Then /^the inflated responses key '(.+)' item '(\d+)' should be a kind of '(.+)'$/ do |key, index, constant| + inflated_response[key][index.to_i].should be_a_kind_of(eval(constant)) +end + +Then /^the inflated responses key '(.+)' item '(\d+)' key '(.+)' should be '(.+)'$/ do |key, index, sub_key, to_equal| + inflated_response[key][index.to_i][sub_key].should == to_equal +end + +Then /^the inflated responses key '(.+)' should be '(\d+)' items long$/ do |key, length| + inflated_response[key].length.should == length.to_i end Then /^the inflated responses key '(.+)' should not exist$/ do |key| - inflated_response.has_key?(key).should == false + self.inflated_response.has_key?(key).should == false end Then /^the inflated responses key '(.+)' should exist$/ do |key| - inflated_response.has_key?(key).should == true + self.inflated_response.has_key?(key).should == true end Then /^the inflated response should be an empty array$/ do - inflated_response.should == [] + self.inflated_response.should == [] +end + +Then /^the inflated response should be an empty hash$/ do + self.inflated_response.should == {} end Then /^the inflated response should include '(.+)'$/ do |entry| - inflated_response.detect { |n| n =~ /#{entry}/ }.should be(true) + puts self.inflated_response.inspect + self.inflated_response.detect { |n| n =~ /#{entry}/ }.should be(true) end Then /^the inflated response should be '(.+)' items long$/ do |length| - inflated_response.length.should == length.to_i + if length.respond_to?(:keys) + self.inflated_response.keys.length.should == length.to_i + else + self.inflated_response.length.should == length.to_i + end end Then /^the '(.+)' header should match '(.+)'$/ do |header, regex| - response.headers[header].should =~ /#{regex}/ + self.response.headers[header].should =~ /#{regex}/ end Then /^the inflated responses key '(.+)' should include '(.+)'$/ do |key, regex| - inflated_response[key].detect { |n| n =~ /#{regex}/ }.should be(true) + self.inflated_response[key].detect { |n| n =~ /#{regex}/ }.should be(true) end Then /^the inflated response should match the '(.+)'$/ do |stash_name| stash[stash_name].each do |k,v| - inflated_response[k.to_s].should == v + self.inflated_response[k.to_s].should == v end end Then /^the inflated response should be the '(.+)'$/ do |stash_key| - stash[stash_key].should == inflated_response + stash[stash_key].should == self.inflated_response end Then /^the inflated response should be a kind of '(.+)'$/ do |thing| - inflated_response.should be_a_kind_of(thing) + self.inflated_response.should be_a_kind_of(thing) end Then /^the inflated response should respond to '(.+)' with '(.+)'$/ do |method, to_match| to_match = JSON.parse(to_match) if to_match =~ /^\[|\{/ - inflated_response.send(method.to_sym).should == to_match + to_match = true if to_match == 'true' + to_match = false if to_match == 'false' + self.inflated_response.send(method.to_sym).should == to_match end Then /^the inflated response should respond to '(.+)' and match '(.+)'$/ do |method, to_match| - inflated_response.send(method.to_sym).should == to_match + self.inflated_response.send(method.to_sym).should == to_match end Then /^the fields in the inflated response should match the '(.+)'$/ do |stash_name| - inflated_response.each do |k,v| + self.inflated_response.each do |k,v| unless k =~ /^_/ || k == 'couchrest-type' stash[stash_name][k.to_sym].should == v end end end +Then /^the data_bag named '(.+)' should not have an item named '(.+)'$/ do |data_bag, item| + exists = true + begin + Chef::DataBagItem.load(data_bag, item, @couchdb) + rescue + exists = false + end + exists.should == false +end features/steps/response_steps.rb @@ -24,7 +24,7 @@ When /^I run the chef\-client$/ do @chef_args ||= "" @config_file ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'data', 'config', 'client.rb')) status = Chef::Mixin::Command.popen4( - "chef-client -l #{@log_level} -c #{@config_file} #{@chef_args}") do |p, i, o, e| + "#{File.join(File.dirname(__FILE__), "..", "..", "chef", "bin", "chef-client")} -l #{@log_level} -c #{@config_file} #{@chef_args}") do |p, i, o, e| @stdout = o.gets(nil) @stderr = e.gets(nil) end @@ -46,17 +46,17 @@ When /^I run the chef\-client with '(.+)' for '(.+)' seconds$/ do |args, run_for end When /^I run the chef\-client for '(.+)' seconds$/ do |run_for| - cid = fork { + cid = Process.fork { sleep run_for.to_i - client_pid = `ps ax | grep chef-client | grep -v grep | grep -v rake | grep -v cucumber | awk '{ print $1 }'` - Process.kill("INT", client_pid.to_i) + Process.kill("INT", /^(.+chef\-client.+\-i.*)$/.match(`ps -ef`).to_s.split[1].to_i) + exit } When 'I run the chef-client' - Process.waitpid2(cid) + Process.wait2(cid) end When /^I run the chef\-client at log level '(.+)'$/ do |log_level| - @log_level = log_level + @log_level = log_level.to_sym When "I run the chef-client" end @@ -76,11 +76,17 @@ log_location File.join(tmpdir, "silly-monkey.log") file_cache_path File.join(tmpdir, "cache") ssl_verify_mode :verify_none registration_url "http://127.0.0.1:4000" -openid_url "http://127.0.0.1:4001" +openid_url "http://127.0.0.1:4000" template_url "http://127.0.0.1:4000" remotefile_url "http://127.0.0.1:4000" search_url "http://127.0.0.1:4000" -couchdb_database 'chef_integration' +role_url "http://127.0.0.1:4000" +client_url "http://127.0.0.1:4000" +chef_server_url "http://127.0.0.1:4000" +validation_client_name "validator" +systmpdir = File.expand_path(File.join(Dir.tmpdir, "chef_integration")) +validation_key File.join(systmpdir, "validation.pem") +client_key File.join(systmpdir, "client.pem") CONFIG @config_file = File.expand_path(File.join(File.dirname(__FILE__), '..', 'data', 'config', 'client-with-logging.rb')) @@ -90,12 +96,11 @@ CONFIG self.cleanup_files << @config_file - @status = Chef::Mixin::Command.popen4("chef-client -c #{@config_file}") do |p, i, o, e| + + @status = Chef::Mixin::Command.popen4("#{File.join(File.dirname(__FILE__), "..", "..", "chef", "bin", "chef-client")} -c #{@config_file} #{@chef_args}") do |p, i, o, e| @stdout = o.gets(nil) @stderr = e.gets(nil) end - - end ### features/steps/run_client_steps.rb @@ -26,7 +26,7 @@ When /^I run chef-solo with the '(.+)' recipe$/ do |recipe_name| cleanup_files << config_file binary_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'chef', 'bin', 'chef-solo')) - command = "chef-solo -c #{config_file} -j #{dna_file}" + command = "#{binary_path} -c #{config_file} -j #{dna_file}" command += " -l debug" if ENV['LOG_LEVEL'] == 'debug' # Run it features/steps/run_solo.rb @@ -36,4 +36,4 @@ end When /^I attach the file at "(.*)" to "(.*)" $/ do |path, field| attach_file(field, path) end - \ No newline at end of file + features/steps/webrat_steps.rb @@ -1,5 +1,3 @@ -# -# Author:: Adam Jacob (<adam@opscode.com>) # Copyright:: Copyright (c) 2008 Opscode, Inc. # License:: Apache License, Version 2.0 # @@ -16,46 +14,126 @@ # limitations under the License. # -%w{chef chef-server chef-server-slice}.each do |inc_dir| +%w{chef chef-server chef-server-slice chef-solr}.each do |inc_dir| $: << File.join(File.dirname(__FILE__), '..', '..', inc_dir, 'lib') end +Thread.abort_on_exception = true + require 'rubygems' require 'spec' require 'chef' require 'chef/config' require 'chef/client' +require 'chef/data_bag' +require 'chef/data_bag_item' +require 'chef/api_client' +require 'chef/solr' +require 'chef/certificate' require 'tmpdir' require 'merb-core' require 'merb_cucumber/world/webrat' +require 'chef/streaming_cookbook_uploader' require 'webrick' def Spec.run? ; true; end -Chef::Config.from_file(File.join(File.dirname(__FILE__), '..', 'data', 'config', 'server.rb')) -Chef::Config[:log_level] = :error -Ohai::Config[:log_level] = :error +ENV['LOG_LEVEL'] ||= 'error' + +def setup_logging + Chef::Config.from_file(File.join(File.dirname(__FILE__), '..', 'data', 'config', 'server.rb')) + Merb.logger.auto_flush = true + if ENV['DEBUG'] == 'true' || ENV['LOG_LEVEL'] == 'debug' + Chef::Config[:log_level] = :debug + Chef::Log.level(:debug) + Merb.logger.set_log(STDOUT, :debug) + else + Chef::Config[:log_level] = ENV['LOG_LEVEL'].to_sym + Chef::Log.level(ENV['LOG_LEVEL'].to_sym) + Merb.logger.set_log(STDOUT, ENV['LOG_LEVEL'].to_sym) + end + Nanite::Log.logger = Ohai::Log.logger = Chef::Log.logger +end + +def setup_nanite + Chef::Config[:nanite_identity] = "chef-integration-test" + Chef::Nanite.in_event { Chef::Log.debug("Nanite is up!") } + Chef::Log.debug("Waiting for Nanites to register with us as a mapper") + sleep 10 +end -if ENV['DEBUG'] = 'true' - Merb.logger.set_log(STDOUT, :debug) if ENV['DEBUG'] = 'true' -else - Merb.logger.set_log(STDOUT, :error) +def delete_databases + c = Chef::REST.new(Chef::Config[:couchdb_url], nil, nil) + %w{chef_integration chef_integration_safe}.each do |db| + begin + c.delete_rest("#{db}/") + rescue + end + end +end + +def create_databases + Chef::Log.info("Creating bootstrap databases") + cdb = Chef::CouchDB.new(Chef::Config[:couchdb_url], "chef_integration") + cdb.create_db + cdb.create_id_map + Chef::Node.create_design_document + Chef::Role.create_design_document + Chef::DataBag.create_design_document + Chef::ApiClient.create_design_document + Chef::Role.sync_from_disk_to_couchdb + Chef::Certificate.generate_signing_ca + Chef::Certificate.gen_validation_key + Chef::Certificate.gen_validation_key(Chef::Config[:web_ui_client_name], Chef::Config[:web_ui_key]) + system("cp #{File.join(Dir.tmpdir, "chef_integration", "validation.pem")} #{Dir.tmpdir}") + system("cp #{File.join(Dir.tmpdir, "chef_integration", "webui.pem")} #{Dir.tmpdir}") +end + +def prepare_replicas + c = Chef::REST.new(Chef::Config[:couchdb_url], nil, nil) + c.put_rest("chef_integration_safe/", nil) + c.post_rest("_replicate", { "source" => "#{Chef::Config[:couchdb_url]}/chef_integration", "target" => "#{Chef::Config[:couchdb_url]}/chef_integration_safe" }) + c.delete_rest("chef_integration") +end + +def cleanup + if File.exists?(Chef::Config[:validation_key]) + File.unlink(Chef::Config[:validation_key]) + end + if File.exists?(Chef::Config[:web_ui_key]) + File.unlink(Chef::Config[:web_ui_key]) + end end Merb.start_environment( - :merb_root => File.join(File.dirname(__FILE__), "..", "..", "chef-server"), + :merb_root => File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "chef-server")), :testing => true, :adapter => 'runner', :environment => ENV['MERB_ENV'] || 'test', :session_store => 'memory' ) +### +# Pre-testing setup +### +setup_logging +setup_nanite +cleanup +delete_databases +create_databases +prepare_replicas + Spec::Runner.configure do |config| config.include(Merb::Test::ViewHelper) config.include(Merb::Test::RouteHelper) config.include(Merb::Test::ControllerHelper) end +Chef::Log.info("Ready to run tests") + +### +# The Cucumber World +### module ChefWorld attr_accessor :recipe, :cookbook, :response, :inflated_response, :log_level, @@ -67,7 +145,7 @@ module ChefWorld end def rest - @rest ||= Chef::REST.new('http://localhost:4000') + @rest ||= Chef::REST.new('http://localhost:4000', nil, nil) end def tmpdir @@ -104,7 +182,24 @@ end World(ChefWorld) +Before do + system("mkdir -p #{tmpdir}") + system("cp -r #{File.join(Dir.tmpdir, "validation.pem")} #{File.join(tmpdir, "validation.pem")}") + system("cp -r #{File.join(Dir.tmpdir, "webui.pem")} #{File.join(tmpdir, "webui.pem")}") + Chef::CouchDB.new(Chef::Config[:couchdb_url], "chef_integration").create_db + c = Chef::REST.new(Chef::Config[:couchdb_url], nil, nil) + c.post_rest("_replicate", { + "source" => "#{Chef::Config[:couchdb_url]}/chef_integration_safe", + "target" => "#{Chef::Config[:couchdb_url]}/chef_integration" + }) +end + After do + r = Chef::REST.new(Chef::Config[:couchdb_url], nil, nil) + r.delete_rest("chef_integration/") + s = Chef::Solr.new + s.solr_delete_by_query("*:*") + s.solr_commit gemserver.shutdown gemserver_thread && gemserver_thread.join @@ -120,5 +215,6 @@ After do end data_tmp = File.join(File.dirname(__FILE__), "..", "data", "tmp") system("rm -rf #{data_tmp}/*") + system("rm -rf #{tmpdir}") end features/support/env.rb chef-server-slice/LICENSE chef-server-slice/NOTICE chef-server-slice/README.rdoc chef-server-slice/Rakefile chef-server-slice/app/controllers/application.rb chef-server-slice/app/controllers/cookbook_files.rb chef-server-slice/app/controllers/cookbook_segment.rb chef-server-slice/app/controllers/cookbook_templates.rb chef-server-slice/app/controllers/cookbooks.rb chef-server-slice/app/controllers/exceptions.rb chef-server-slice/app/controllers/main.rb chef-server-slice/app/controllers/nodes.rb chef-server-slice/app/controllers/openid_consumer.rb chef-server-slice/app/controllers/openid_register.rb chef-server-slice/app/controllers/openid_server.rb chef-server-slice/app/controllers/roles.rb chef-server-slice/app/controllers/search.rb chef-server-slice/app/controllers/search_entries.rb chef-server-slice/app/controllers/status.rb chef-server-slice/app/helpers/application_helper.rb chef-server-slice/app/helpers/cookbook_attributes_helper.rb chef-server-slice/app/helpers/cookbook_definitions_helper.rb chef-server-slice/app/helpers/cookbook_files_helper.rb chef-server-slice/app/helpers/cookbook_libraries_helper.rb chef-server-slice/app/helpers/cookbook_recipes_helper.rb chef-server-slice/app/helpers/cookbook_templates_helper.rb chef-server-slice/app/helpers/cookbooks_helper.rb chef-server-slice/app/helpers/exceptions_helper.rb chef-server-slice/app/helpers/global_helpers.rb chef-server-slice/app/helpers/nodes_helper.rb chef-server-slice/app/helpers/openid_consumer_helper.rb chef-server-slice/app/helpers/openid_register_helper.rb chef-server-slice/app/helpers/openid_server_helper.rb chef-server-slice/app/helpers/openid_server_helpers.rb chef-server-slice/app/helpers/roles_helper.rb chef-server-slice/app/helpers/search_entries_helper.rb chef-server-slice/app/helpers/search_helper.rb chef-server-slice/app/helpers/status_helper.rb chef-server-slice/app/views/cookbook_templates/index.html.haml chef-server-slice/app/views/cookbooks/index.html.haml chef-server-slice/app/views/cookbooks/show.html.haml chef-server-slice/app/views/exceptions/bad_request.json.erb chef-server-slice/app/views/exceptions/internal_server_error.html.erb chef-server-slice/app/views/exceptions/not_acceptable.html.erb chef-server-slice/app/views/exceptions/not_found.html.erb chef-server-slice/app/views/exceptions/standard_error.html.erb chef-server-slice/app/views/layout/chef_server_slice.html.haml chef-server-slice/app/views/layout/login.html.haml chef-server-slice/app/views/main/index.html.erb chef-server-slice/app/views/nodes/_action.html.haml chef-server-slice/app/views/nodes/_form.html.haml chef-server-slice/app/views/nodes/_navigation.html.haml chef-server-slice/app/views/nodes/_resource.html.haml chef-server-slice/app/views/nodes/edit.html.haml chef-server-slice/app/views/nodes/index.html.haml chef-server-slice/app/views/nodes/new.html.haml chef-server-slice/app/views/nodes/show.html.haml chef-server-slice/app/views/openid_consumer/index.html.haml chef-server-slice/app/views/openid_consumer/start.html.haml chef-server-slice/app/views/openid_login/index.html.haml chef-server-slice/app/views/openid_register/index.html.haml chef-server-slice/app/views/openid_register/show.html.haml chef-server-slice/app/views/openid_server/decide.html.haml chef-server-slice/app/views/roles/_form.html.haml chef-server-slice/app/views/roles/_navigation.html.haml chef-server-slice/app/views/roles/edit.html.haml chef-server-slice/app/views/roles/index.html.haml chef-server-slice/app/views/roles/new.html.haml chef-server-slice/app/views/roles/show.html.haml chef-server-slice/app/views/search/_search_form.html.haml chef-server-slice/app/views/search/index.html.haml chef-server-slice/app/views/search/show.html.haml chef-server-slice/app/views/search_entries/index.html.haml chef-server-slice/app/views/search_entries/show.html.haml chef-server-slice/app/views/status/index.html.haml chef-server-slice/config/init.rb chef-server-slice/config/router.rb chef-server-slice/lib/chef-server-slice.rb chef-server-slice/lib/chef-server-slice/merbtasks.rb chef-server-slice/lib/chef-server-slice/slicetasks.rb chef-server-slice/lib/chef-server-slice/spectasks.rb chef-server-slice/public/facebox/README.txt chef-server-slice/public/facebox/b.png chef-server-slice/public/facebox/bl.png chef-server-slice/public/facebox/br.png chef-server-slice/public/facebox/closelabel.gif chef-server-slice/public/facebox/facebox.css chef-server-slice/public/facebox/facebox.js chef-server-slice/public/facebox/loading.gif chef-server-slice/public/facebox/tl.png chef-server-slice/public/facebox/tr.png chef-server-slice/public/images/avatar.png chef-server-slice/public/images/black_big.png chef-server-slice/public/images/indicator.gif chef-server-slice/public/images/merb.jpg chef-server-slice/public/images/toggle-collapse-dark.png chef-server-slice/public/images/toggle-collapse-light.png chef-server-slice/public/images/toggle-collapse.gif chef-server-slice/public/images/toggle-expand-dark.png chef-server-slice/public/images/toggle-expand-light.png chef-server-slice/public/images/toggle-expand.gif chef-server-slice/public/images/treeBuilderImages/Thumbs.db chef-server-slice/public/images/treeBuilderImages/doc.gif chef-server-slice/public/images/treeBuilderImages/docNode.gif chef-server-slice/public/images/treeBuilderImages/docNodeLast.gif chef-server-slice/public/images/treeBuilderImages/docNodeLastFirst.gif chef-server-slice/public/images/treeBuilderImages/folder.gif chef-server-slice/public/images/treeBuilderImages/folderNode.gif chef-server-slice/public/images/treeBuilderImages/folderNodeFirst.gif chef-server-slice/public/images/treeBuilderImages/folderNodeLast.gif chef-server-slice/public/images/treeBuilderImages/folderNodeLastFirst.gif chef-server-slice/public/images/treeBuilderImages/folderNodeOpen.gif chef-server-slice/public/images/treeBuilderImages/folderNodeOpenFirst.gif chef-server-slice/public/images/treeBuilderImages/folderNodeOpenLast.gif chef-server-slice/public/images/treeBuilderImages/folderNodeOpenLastFirst.gif chef-server-slice/public/images/treeBuilderImages/folderOpen.gif chef-server-slice/public/images/treeBuilderImages/vertLine.gif chef-server-slice/public/javascripts/JSONeditor.js chef-server-slice/public/javascripts/chef.js chef-server-slice/public/javascripts/jquery-1.3.2.min.js chef-server-slice/public/javascripts/jquery-ui-1.7.1.custom.min.js chef-server-slice/public/javascripts/jquery.editinline.js chef-server-slice/public/javascripts/jquery.jeditable.mini.js chef-server-slice/public/javascripts/jquery.livequery.js chef-server-slice/public/javascripts/jquery.localscroll.js chef-server-slice/public/javascripts/jquery.scrollTo.js chef-server-slice/public/javascripts/jquery.tools.min.js chef-server-slice/public/javascripts/jquery.treeTable.min.js chef-server-slice/public/stylesheets/base.css chef-server-slice/public/stylesheets/chef.css chef-server-slice/public/stylesheets/images/ui-bg_diagonals-small_0_aaaaaa_40x40.png chef-server-slice/public/stylesheets/images/ui-bg_diagonals-thick_15_444444_40x40.png chef-server-slice/public/stylesheets/images/ui-bg_glass_100_f0f0f0_1x400.png chef-server-slice/public/stylesheets/images/ui-bg_glass_50_99c2ff_1x400.png chef-server-slice/public/stylesheets/images/ui-bg_glass_55_fbf5d0_1x400.png chef-server-slice/public/stylesheets/images/ui-bg_glass_80_e6e6e6_1x400.png chef-server-slice/public/stylesheets/images/ui-bg_glass_95_fef1ec_1x400.png chef-server-slice/public/stylesheets/images/ui-bg_highlight-hard_100_f9f9f9_1x100.png chef-server-slice/public/stylesheets/images/ui-bg_highlight-soft_100_e7eef3_1x100.png chef-server-slice/public/stylesheets/images/ui-icons_222222_256x240.png chef-server-slice/public/stylesheets/images/ui-icons_2694e8_256x240.png chef-server-slice/public/stylesheets/images/ui-icons_2e83ff_256x240.png chef-server-slice/public/stylesheets/images/ui-icons_72a7cf_256x240.png chef-server-slice/public/stylesheets/images/ui-icons_888888_256x240.png chef-server-slice/public/stylesheets/images/ui-icons_cd0a0a_256x240.png chef-server-slice/public/stylesheets/images/ui-icons_ffffff_256x240.png chef-server-slice/public/stylesheets/jquery-ui-1.7.1.custom.css chef-server-slice/public/stylesheets/jquery.treeTable.css chef-server-slice/public/stylesheets/themes/bec-green/style.css chef-server-slice/public/stylesheets/themes/bec/style.css chef-server-slice/public/stylesheets/themes/blue/style.css chef-server-slice/public/stylesheets/themes/default/style.css chef-server-slice/public/stylesheets/themes/djime-cerulean/style.css chef-server-slice/public/stylesheets/themes/kathleene/style.css chef-server-slice/public/stylesheets/themes/orange/style.css chef-server-slice/public/stylesheets/themes/reidb-greenish/style.css chef/lib/chef/application/indexer.rb chef/lib/chef/queue.rb chef/lib/chef/search.rb chef/lib/chef/search/result.rb chef/lib/chef/search_index.rb chef/spec/unit/application/indexer_spec.rb chef/spec/unit/queue_spec.rb chef/spec/unit/search/result_spec.rb features/steps/couchdb_steps.rb 1404ace1ae1eb9bc43447342da2592fd1d802498 b6ffd6b2cb69007994697144561f16f0debaff06 Adam Jacob adam@opscode.com http://github.com/opscode/chef/commit/7971a7ccf8a8436aada34c810b93e013557e92cb 7971a7ccf8a8436aada34c810b93e013557e92cb 2009-10-29T08:44:51-07:00 2009-10-29T08:44:51-07:00 Merge branch 'master' into danielsdeleo/CHEF-626 018565f9a3b22be7d746ce10fad45c320a78a3ce Adam Jacob adam@opscode.com