knife-sharp 0.4.5 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b78ccd3e3e6bbc90de1f096bbacbabf3d0c425d0
-  data.tar.gz: d0c0aa39d3c612b4967af96edbe28b297ba3ac19
+  metadata.gz: ca5eb5868e371ab216bf8009f49fc1341b0884dd
+  data.tar.gz: 4f2471fc8a99e9372dd459c9c0da29e7e5d9f862
 SHA512:
-  metadata.gz: 3988ac9a8e7986a48000f517aba4d507dee19291a619fcb87db86cc82aa544be2bcd7a583661902650df9c226ad124613fde5ce066fc7c58748cfd134356d8f8
-  data.tar.gz: 0576546edf62936eb81209157f56d8dab59f4b0540d963e535a05ded5fbaa44587b421d25eba8b50799c01cd058f51ecab2e5c1dafe463a89abf68c0eca646c4
+  metadata.gz: bdf6f7d68cfc0806231fedec65d4e074ea97bddbef433ee8f58ec9f180200c7337f8accf8e530919275a3d12f0f8dbb13672756faa8c482aeff8b82373f74be2
+  data.tar.gz: 732dcc82d02814c8d7e4fba9d00b1aaa2dd2037fae214cbb5e36d1e91769369ecdad99ac512adbc96b005913bf9f9aa954b50b90cc805a9382512e282637104b

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+pkg
+.ruby-gemset
+.ruby-version

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/Gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: .
+  specs:
+    knife-sharp (0.5.0)
+      chef (>= 11)
+      grit (~> 2.5)
+
+GEM
+  specs:
+    chef (12.0.3)
+      chef-zero (~> 3.2)
+      diff-lcs (~> 1.2, >= 1.2.4)
+      erubis (~> 2.7)
+      ffi-yajl (~> 1.2)
+      highline (~> 1.6, >= 1.6.9)
+      mixlib-authentication (~> 1.3)
+      mixlib-cli (~> 1.4)
+      mixlib-config (~> 2.0)
+      mixlib-log (~> 1.3)
+      mixlib-shellout (>= 2.0.0.rc.0, < 3.0)
+      net-ssh (~> 2.6)
+      net-ssh-multi (~> 1.1)
+      ohai (~> 8.0)
+      plist (~> 3.1.0)
+      pry (~> 0.9)
+    chef-zero (3.2.1)
+      ffi-yajl (~> 1.1)
+      hashie (~> 2.0)
+      mixlib-log (~> 1.3)
+      rack
+      uuidtools (~> 2.1)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    ffi (1.9.6)
+    ffi-yajl (1.3.1)
+      ffi (~> 1.5)
+      libyajl2 (~> 1.2)
+    grit (2.5.0)
+      diff-lcs (~> 1.1)
+      mime-types (~> 1.15)
+      posix-spawn (~> 0.3.6)
+    hashie (2.1.2)
+    highline (1.6.21)
+    ipaddress (0.8.0)
+    libyajl2 (1.2.0)
+    method_source (0.8.2)
+    mime-types (1.25.1)
+    mixlib-authentication (1.3.0)
+      mixlib-log
+    mixlib-cli (1.5.0)
+    mixlib-config (2.1.0)
+    mixlib-log (1.6.0)
+    mixlib-shellout (2.0.1)
+    net-dhcp (1.3.2)
+    net-ssh (2.9.2)
+    net-ssh-gateway (1.2.0)
+      net-ssh (>= 2.6.5)
+    net-ssh-multi (1.2.0)
+      net-ssh (>= 2.6.5)
+      net-ssh-gateway (>= 1.2.0)
+    ohai (8.0.1)
+      ffi (~> 1.9)
+      ffi-yajl (~> 1.1)
+      ipaddress
+      mime-types (~> 1.16)
+      mixlib-cli
+      mixlib-config (~> 2.0)
+      mixlib-log
+      mixlib-shellout (~> 2.0)
+      net-dhcp
+      rake (~> 10.1)
+      systemu (~> 2.6.4)
+      wmi-lite (~> 1.0)
+    plist (3.1.0)
+    posix-spawn (0.3.9)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.6.0)
+    rake (10.1.0)
+    slop (3.6.0)
+    systemu (2.6.4)
+    uuidtools (2.1.5)
+    wmi-lite (1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  knife-sharp!

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake'
+
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+
+# tasks
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end

data/knife-sharp.gemspec

@@ -0,0 +1,20 @@
+require 'date'
+require File.join(File.dirname(__FILE__), "lib", "knife-sharp.rb")
+
+Gem::Specification.new do |s|
+  s.name        = 'knife-sharp'
+  s.version     = KnifeSharp::VERSION
+  s.date        = Date.today.to_s
+  s.summary     = "Knife sharp plugin"
+  s.description = "Sharpen your knife"
+  s.homepage    = "https://github.com/Fotolia/knife-sharp"
+  s.authors     = [ "Nicolas Szalay", "Jonathan Amiez" ]
+  s.email       = [ "nico@rottenbytes.info", "jonathan.amiez@gmail.com" ]
+  s.license     = "3-BSD"
+
+  s.files       = %x(git ls-files).split("\n")
+  s.require_paths = [ "lib" ]
+
+  s.add_dependency "chef", ">= 11"
+  s.add_dependency "grit", "~> 2.5"
+end

data/lib/chef/knife/sharp-align.rb

@@ -1,8 +1,10 @@
 require 'chef/knife'
+require 'knife-sharp/common'
 require 'grit'
 
 module KnifeSharp
   class SharpAlign < Chef::Knife
+    include KnifeSharp::Common
 
     banner "knife sharp align BRANCH ENVIRONMENT [OPTS]"
 
@@ -26,483 +28,42 @@ module KnifeSharp
       :description => "dump items not present locally (roles/databags)",
       :default => false
 
-    deps do
-      require 'chef/environment'
-      require 'chef/role'
-      require 'chef/cookbook/metadata'
-      require 'chef/cookbook_loader'
-      require 'chef/cookbook_uploader'
-    end
-
     def run
-      setup()
-      ui.msg(ui.color("On server #{@chef_server}", :bold)) if @chef_server
-      check_cookbooks if @do_cookbooks
-      check_databags if @do_databags
-      check_roles if @do_roles
-
-      # All questions asked, can we proceed ?
-      if @cookbooks.empty? and @databags.empty? and @roles.empty?
-        ui.msg "Nothing else to do"
-        exit 0
-      end
-
-      ui.confirm(ui.color("> Proceed ", :bold))
-      bump_cookbooks if @do_cookbooks
-      update_databags if @do_databags
-      update_roles if @do_roles
-    end
-
-    def setup
       # Checking args
-      if name_args.count != 2
-        show_usage
-        exit 1
-      end
+      ensure_branch_and_environment_provided!
+
+      # Checking repo branch
+      ensure_correct_branch_provided!
 
       # check cli flags
       if config[:cookbooks] or config[:databags] or config[:roles]
-        @do_cookbooks, @do_databags, @do_roles = config[:cookbooks], config[:databags], config[:roles]
-      else
-        @do_cookbooks, @do_databags, @do_roles = true, true, true
-      end
-
-      # Sharp config
-      cfg_files = [ "/etc/sharp-config.yml", "~/.chef/sharp-config.yml" ]
-      loaded = false
-      cfg_files.each do |cfg_file|
-        begin
-          @cfg = YAML::load_file(File.expand_path(cfg_file))
-          loaded = true
-        rescue Exception => e
-          ui.error "Error on loading config : #{e.inspect}" if config[:verbosity] > 0
-        end
-      end
-      unless loaded == true
-        ui.error "config could not be loaded ! Tried the following files : #{cfg_files.join(", ")}"
-        exit 1
-      end
-
-      # Env setup
-      @branch, @environment = name_args
-      @chef_path = @cfg["global"]["git_cookbook_path"]
-
-      # Checking current branch
-      current_branch = Grit::Repo.new(@chef_path).head.name
-      if @branch != current_branch then
-        ui.error "Git repo is actually on branch #{current_branch} but you want to align using #{@branch}. Checkout to the desired one."
-        exit 1
-      end
-
-      # Knife config
-      if Chef::Knife.chef_config_dir && File.exists?(File.join(Chef::Knife.chef_config_dir, "knife.rb"))
-        Chef::Config.from_file(File.join(Chef::Knife.chef_config_dir, "knife.rb"))
-      else
-        ui.error "Cannot find knife.rb config file"
-        exit 1
-      end
-
-      # Logger
-      if @cfg["logging"]["enabled"]
-        begin
-          require "logger"
-          log_file = File.expand_path(@cfg["logging"]["destination"])
-          @log = Logger.new(log_file)
-        rescue Exception => e
-          ui.error "Unable to set up logger (#{e.inspect})."
-          exit 1
-        end
-      end
-
-      chefcfg = Chef::Config
-      @cb_path = chefcfg.cookbook_path.is_a?(Array) ? chefcfg.cookbook_path.first : chefcfg.cookbook_path
-      @db_path = chefcfg.data_bag_path.is_a?(Array) ? chefcfg.data_bag_path.first : chefcfg.data_bag_path
-      @role_path = chefcfg.role_path.is_a?(Array) ? chefcfg.role_path.first : chefcfg.role_path
-
-      @chef_server = SharpServer.new.current_server
-      @loader = Chef::CookbookLoader.new(@cb_path)
-
-      @cookbooks = Array.new
-      @databags = Hash.new
-      @roles = Hash.new
-    end
-
-    ### Cookbook methods ###
-
-    def check_cookbooks
-      unless File.exists?(@cb_path)
-        ui.warn "Bad cookbook path, skipping cookbook sync."
-        return
-      end
-
-      ui.msg(ui.color("== Cookbooks ==", :bold))
-
-      updated_versions = Hash.new
-      local_versions = Hash[Dir.glob("#{@cb_path}/*").select {|cb| File.directory?(cb)}.map {|cb| [File.basename(cb), @loader[File.basename(cb)].version] }]
-      remote_versions = Chef::Environment.load(@environment).cookbook_versions.each_value {|v| v.gsub!("= ", "")}
-
-      if local_versions.empty?
-        ui.warn "No local cookbooks found, is the cookbook path correct ? (#{@cb_path})"
-        return
-      end
-
-      # get local-only cookbooks
-      (local_versions.keys - remote_versions.keys).each do |cb|
-        updated_versions[cb] = local_versions[cb]
-        ui.msg "* #{cb} is local only (version #{local_versions[cb]})"
-      end
-
-      # get cookbooks not up-to-date
-      (remote_versions.keys & local_versions.keys).each do |cb|
-        if Chef::VersionConstraint.new("> #{remote_versions[cb]}").include?(local_versions[cb])
-          updated_versions[cb] = local_versions[cb]
-          ui.msg "* #{cb} is not up-to-date (local: #{local_versions[cb]}/remote: #{remote_versions[cb]})"
-        elsif Chef::VersionConstraint.new("> #{local_versions[cb]}").include?(remote_versions[cb]) and config[:force_align]
-          updated_versions[cb] = local_versions[cb]
-          ui.msg "* #{cb} is to be downgraded (local: #{local_versions[cb]}/remote: #{remote_versions[cb]})"
-        end
-      end
-
-      if @cfg[@chef_server] and @cfg[@chef_server].has_key?("ignore_cookbooks")
-        (updated_versions.keys & @cfg[@chef_server]["ignore_cookbooks"]).each do |cb|
-          updated_versions.delete(cb)
-          ui.msg "* Skipping #{cb} cookbook (ignore list)"
-        end
-      end
-
-      if !updated_versions.empty?
-        all = false
-        updated_versions.each_pair do |cb,version|
-          answer = ui.ask_question("> Update #{cb} cookbook to #{version} on server ? Y/N/(A)ll/(Q)uit ", :default => "N").upcase unless all
-
-          if answer == "A"
-            all = true
-          elsif answer == "Q"
-            ui.msg "* Skipping next cookbooks alignment."
-            break
-          end
-
-          if all or answer == "Y"
-            @cookbooks << cb
-          else
-            ui.msg "* Skipping #{cb} cookbook"
-          end
-        end
-      else
-        ui.msg "* Environment #{@environment} is up-to-date."
-      end
-    end
-
-
-    def bump_cookbooks
-      unless @cookbooks.empty?
-        env = Chef::Environment.load(@environment)
-        cbs = Array.new
-        backup_data = Hash.new
-        backup_data["environment"] = @environment
-        backup_data["cookbook_versions"] = Hash.new
-        @cookbooks.each do |cb_name|
-          cb = @loader[cb_name]
-          if @cfg["rollback"] && @cfg["rollback"]["enabled"] == true
-            backup_data["cookbook_versions"][cb_name] = env.cookbook_versions[cb_name]
-          end
-          # Force "= a.b.c" in cookbook version, as chef11 will not accept "a.b.c"
-          env.cookbook_versions[cb_name] = "= #{cb.version}"
-          cbs << cb
-        end
-
-        ui.msg "* Uploading cookbook(s) #{@cookbooks.join(", ")}"
-        cookbook_uploader(cbs).upload_cookbooks
-
-
-        if env.save
-          cbs.each do |cb|
-            ui.msg "* Bumping #{cb.name} to #{cb.version} for environment #{@environment}"
-            log_action("bumping #{cb.name} to #{cb.version} for environment #{@environment}")
-          end
-        end
-
-        if @cfg["rollback"] && @cfg["rollback"]["enabled"] == true
-          identifier = Time.now.to_i
-          Dir.mkdir(@cfg["rollback"]["destination"]) unless File.exists?(@cfg["rollback"]["destination"])
-          fp = open(File.join(@cfg["rollback"]["destination"], "#{identifier}.json"), "w")
-          fp.write(JSON.pretty_generate(backup_data))
-          fp.close()
-        end
-      end
-    end
-
-    ### Databag methods ###
-
-    def check_databags
-      unless File.exists?(@db_path)
-        ui.warn "Bad data bag path, skipping data bag sync."
-        return
-      end
-
-      ui.msg(ui.color("== Data bags ==", :bold))
-
-      updated_dbs = Hash.new
-      local_dbs = Dir.glob(File.join(@db_path, "**/*.json")).map {|f| [File.dirname(f).split("/").last, File.basename(f, ".json")]}
-      remote_dbs = Chef::DataBag.list.keys.map {|db| Chef::DataBag.load(db).keys.map{|dbi| [db, dbi]}}.flatten(1)
-
-      if local_dbs.empty?
-        ui.warn "No local data bags found, is the data bag path correct ? (#{@db_path})"
-        return
-      end
-
-      # Dump missing data bags locally
-      (remote_dbs - local_dbs).each do |db|
-        ui.msg "* #{db.join("/")} data bag item is remote only"
-        if config[:dump_remote_only]
-          ui.msg "* Dumping to #{File.join(@db_path, "#{db.join("/")}.json")}"
-          begin
-            remote_db = Chef::DataBagItem.load(db.first, db.last).raw_data
-            Dir.mkdir(File.join(@db_path, db.first)) unless File.exists?(File.join(@db_path, db.first))
-            File.open(File.join(@db_path, "#{db.join("/")}.json"), "w") do |file|
-              file.puts JSON.pretty_generate(remote_db)
-            end
-          rescue Exception => e
-            ui.error "Unable to dump #{db.join("/")} data bag item (#{e.message})"
-          end
-        end
-      end
-
-      # Create new data bags on server
-      (local_dbs - remote_dbs).each do |db|
-        begin
-          local_db = JSON::load(File.read(File.join(@db_path, "#{db.join("/")}.json")))
-          updated_dbs[db] = local_db
-          ui.msg "* #{db.join("/")} data bag item is local only"
-        rescue Exception => e
-          ui.error "Unable to load #{db.join("/")} data bag item (#{e.message})"
-        end
-      end
-
-      # Compare roles common to local and remote
-      (remote_dbs & local_dbs).each do |db|
-        begin
-          remote_db = Chef::DataBagItem.load(db.first, db.last).raw_data
-          local_db = JSON::load(File.read(File.join(@db_path, "#{db.join("/")}.json")))
-          if remote_db != local_db
-            updated_dbs[db] = local_db
-            ui.msg("* #{db.join("/")} data bag item is not up-to-date")
-          end
-        rescue Exception => e
-          ui.error "Unable to load #{db.join("/")} data bag item (#{e.message})"
-        end
-      end
-
-      if @cfg[@chef_server] and @cfg[@chef_server].has_key?("ignore_databags")
-        (updated_dbs.keys.map{|k| k.join("/")} & @cfg[@chef_server]["ignore_databags"]).each do |db|
-          updated_dbs.delete(db.split("/"))
-          ui.msg "* Skipping #{db} data bag (ignore list)"
-        end
-      end
-
-      if !updated_dbs.empty?
-        all = false
-        updated_dbs.each do |name, obj|
-          answer = nil
-          answer = ui.ask_question("> Update #{name.join("/")} data bag item on server ? Y/N/(A)ll/(Q)uit ", :default => "N").upcase unless all
-
-          if answer == "A"
-            all = true
-          elsif answer == "Q"
-            ui.msg "* Aborting data bag alignment."
-            break
-          end
-
-          if all or answer == "Y"
-            @databags[name] = obj
-          else
-            ui.msg "* Skipping #{name.join("/")} data bag item"
-          end
-        end
-      else
-        ui.msg "* Data bags are up-to-date."
-      end
-    end
-
-    def update_databags
-      parent_databags = Chef::DataBag.list.keys
-      unless @databags.empty?
-        @databags.each do |name, obj|
-          begin
-            # create the parent if needed
-            unless parent_databags.include?(name.first)
-              db = Chef::DataBag.new
-              db.name(name.first)
-              db.create
-              # add it to the list to avoid trying to recreate it
-              parent_databags.push(name.first)
-              ui.msg("* Creating data bag #{name.first}")
-              log_action("creating data bag #{name.first}")
-            end
-            db = Chef::DataBagItem.new
-            db.data_bag(name.first)
-            db.raw_data = obj
-            db.save
-            ui.msg "* Updating #{name.join("/")} data bag item"
-            log_action("updating #{name.join("/")} data bag item")
-          rescue Exception => e
-            ui.error "Unable to update #{name.join("/")} data bag item"
-          end
-        end
-      end
-    end
-
-    ### Role methods ###
-
-    def check_roles
-      # role sections to compare (methods)
-      to_check = {
-        "env_run_lists" => "run list",
-        "default_attributes" => "default attributes",
-        "override_attributes" => "override attributes"
-      }
-
-      unless File.exists?(@role_path)
-        ui.warn "Bad role path, skipping role sync."
-        return
-      end
-
-      ui.msg(ui.color("== Roles ==", :bold))
-
-      updated_roles = Hash.new
-      local_roles = Dir.glob(File.join(@role_path, "*.json")).map {|file| File.basename(file, ".json")}
-      remote_roles = Chef::Role.list.keys
-
-      if local_roles.empty?
-        ui.warn "No local roles found, is the role path correct ? (#{@role_path})"
-        return
-      end
-
-      # Dump missing roles locally
-      (remote_roles - local_roles).each do |role|
-        ui.msg "* #{role} role is remote only"
-        if config[:dump_remote_only]
-          ui.msg "* Dumping to #{File.join(@role_path, "#{role}.json")}"
-          begin
-            remote_role = Chef::Role.load(role)
-            File.open(File.join(@role_path, "#{role}.json"), "w") do |file|
-              file.puts JSON.pretty_generate(remote_role)
-            end
-          rescue Exception => e
-            ui.error "Unable to dump #{role} role (#{e.message})"
-          end
-        end
-      end
-
-      # Create new roles on server
-      (local_roles - remote_roles).each do |role|
-        begin
-          local_role = Chef::Role.from_disk(role)
-          updated_roles[role] = local_role
-          ui.msg "* #{role} role is local only"
-        rescue Exception => e
-          ui.error "Unable to load #{role} role (#{e.message})"
-        end
-      end
-
-      # Compare roles common to local and remote
-      (remote_roles & local_roles).each do |role|
-        remote_role = Chef::Role.load(role)
-        local_role = Chef::Role.from_disk(role)
-
-        diffs = Array.new
-        to_check.each do |method, display|
-          if remote_role.send(method) != local_role.send(method)
-            updated_roles[role] = local_role
-            diffs << display
-          end
-        end
-        ui.msg("* #{role} role is not up-to-date (#{diffs.join(",")})") unless diffs.empty?
-      end
-
-      if @cfg[@chef_server] and @cfg[@chef_server].has_key?("ignore_roles")
-        (updated_roles.keys & @cfg[@chef_server]["ignore_roles"]).each do |r|
-          updated_roles.delete(r)
-          ui.msg "* Skipping #{r} role (ignore list)"
-        end
-      end
-
-      if !updated_roles.empty?
-        all = false
-        updated_roles.each do |name, obj|
-          answer = ui.ask_question("> Update #{name} role on server ? Y/N/(A)ll/(Q)uit ", :default => "N").upcase unless all
-
-          if answer == "A"
-            all = true
-          elsif answer == "Q"
-            ui.msg "* Aborting role alignment."
-            break
-          end
-
-          if all or answer == "Y"
-            @roles[name] = obj
-          else
-            ui.msg "* Skipping #{name} role"
-          end
-        end
+        do_cookbooks, do_databags, do_roles = config[:cookbooks], config[:databags], config[:roles]
       else
-        ui.msg "* Roles are up-to-date."
+        do_cookbooks, do_databags, do_roles = true, true, true
       end
-    end
 
-    def update_roles
-      unless @roles.empty?
-        @roles.each do |name, obj|
-          begin
-            obj.save
-            ui.msg "* Updating #{name} role"
-            log_action("updating #{name} role")
-          rescue Exception => e
-            ui.error "Unable to update #{name} role"
-          end
-        end
-      end
-    end
-
-    ### Utility methods ###
-
-    def log_action(message)
-      # log file if enabled
-      log_message = message
-      log_message += " on server #{@chef_server}" if @chef_server
-      @log.info(log_message) if @cfg["logging"]["enabled"]
+      ui.msg(ui.color("On server #{chef_server}", :bold)) if chef_server
 
-      # any defined notification method (currently, only hubot, defined below)
-      if @cfg["notification"]
-        @cfg["notification"].each do |carrier, data|
-          skipped = Array.new
-          skipped = data["skip"] if data["skip"]
-
-          if data["enabled"] and !skipped.include?(@chef_server)
-            send(carrier, message, data)
-          end
-        end
-      end
-    end
+      SharpCookbookAlign.load_deps
+      sca = SharpCookbookAlign.new
+      cookbooks_to_update = do_cookbooks ? sca.check_cookbooks(environment) : []
+      SharpDataBagAlign.load_deps
+      sda = SharpDataBagAlign.new
+      databags_to_update = do_databags ? sda.check_databags : {}
+      SharpRoleAlign.load_deps
+      sra = SharpRoleAlign.new
+      roles_to_update = do_roles ? sra.check_roles : {}
 
-    def hubot(message, config={})
-      begin
-        require "net/http"
-        require "uri"
-        uri = URI.parse("#{config["url"]}/#{config["channel"]}")
-        notif = "chef: #{message} by #{config["username"]}"
-        Net::HTTP.post_form(uri, { "message" => notif })
-      rescue
-        ui.error "Unable to notify via hubot."
+      # All questions asked, can we proceed ?
+      if cookbooks_to_update.empty? and databags_to_update.empty? and roles_to_update.empty?
+        ui.msg "Nothing else to do"
+        exit 0
       end
-    end
 
-    def cookbook_uploader(cookbooks)
-      if Gem::Version.new(Chef::VERSION).release >= Gem::Version.new('12.0.0')
-        uploader = Chef::CookbookUploader.new(cookbooks)
-      else
-        uploader = Chef::CookbookUploader.new(cookbooks, Chef::Config.cookbook_path)
-      end
+      ui.confirm(ui.color("> Proceed ", :bold))
+      sca.bump_cookbooks(environment, cookbooks_to_update) if do_cookbooks
+      sda.update_databags(databags_to_update) if do_databags
+      sra.update_roles(roles_to_update) if do_roles
     end
   end
 end