chef-metal 0.11.beta.2 → 0.11.beta.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 856d6cabfcf4414a418cc036d3b9214126a91162
-  data.tar.gz: c31563bac13782c4445ae2d69a7e69ee2ff9c4f3
+  metadata.gz: 1ddce3b9695b8227fa35fc0eef02506df0c8107d
+  data.tar.gz: 3d1fd09662aa1d39d4badd40d00e28792b6a2263
 SHA512:
-  metadata.gz: 1a689a1bb4f4cf63da67d784d2dfe818fd8c28c516de6aec74896f96dbe6bf7f7b01c3db25e9079493d3ba144ef31c12f975900dba8e6e5c38bfb52d55f9b7d4
-  data.tar.gz: cb9456dc0eea0944fadbdcd553571ccff00ccf6df8fb75198ff3da34c5c953fc5a526948f4200423d9f79c591b39ef43077782e2b68f9ed4fdd2e6ca5307318f
+  metadata.gz: e518ac22332cabb69df9bb5a77beedfbdbc4ac37e5a8a50d3f06272bf346b9b1b343891c5f593e8f61447ce1ea8569a039438c940696935e3dfcb569fb783de9
+  data.tar.gz: d4b8d64ef682e3bab426f273030ee01e2f8a176b5079263a51733180d10a5168979c57b0805491f281d27bc0c9deff691d1953c5b9d0ae2aa0d5151fa110719b

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Chef Metal Changelog
 
+## 0.11.beta.2 (5/27/2014)
+
+- Bring in cheffish-0.5.beta.2
+
 ## 0.11.beta (5/23/2014)
 
 - New Driver interface (see docs/ and blogs/ directories for documentation)

data/bin/metal

@@ -10,6 +10,7 @@ require 'chef/run_context'
 require 'chef/server_api'
 require 'chef_metal/action_handler'
 require 'chef_metal/version'
+require 'chef_metal/chef_machine_spec'
 
 class ChefMetal::Application < Chef::Application
 
@@ -92,20 +93,6 @@ class ChefMetal::Application < Chef::Application
       Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
     end
     Chef::Config.chef_zero.port = config[:chef_zero_port] if config[:chef_zero_port]
-
-    if Chef::Config[:daemonize]
-      Chef::Config[:interval] ||= 1800
-    end
-
-    if Chef::Config[:once]
-      Chef::Config[:interval] = nil
-      Chef::Config[:splay] = nil
-    end
-
-    if Chef::Config[:json_attribs]
-      config_fetcher = Chef::ConfigFetcher.new(Chef::Config[:json_attribs])
-      @chef_client_json = config_fetcher.fetch_json
-    end
   end
 
   def setup_application
@@ -120,89 +107,107 @@ class ChefMetal::Application < Chef::Application
   end
 
   def run_application
-    Chef::Application.setup_server_connectivity
-
-    command = cli_arguments.shift
     exit_code = 0
-    case command
-    when 'execute'
-      each_machine(cli_arguments.shift) do |machine, provisioner|
-        result = machine.execute(action_handler, cli_arguments.join(' '), :read_only => config[:read_only], :stream => config[:stream], :timeout => config[:timeout].to_f)
-        puts result.stdout if result.stdout != '' && !config[:stream] && Chef::Config.log_level != :debug
-        STDERR.puts result.stderr if result.stderr != '' && !config[:stream] && Chef::Config.log_level != :debug
-        exit_code = result.exitstatus if result.exitstatus != 0
-      end
-    when 'converge'
-      each_machine(cli_arguments.shift) do |machine, provisioner|
-        machine.converge(action_handler)
-      end
-    when 'delete'
-      each_machine(cli_arguments.shift) do |machine, provisioner|
-        provisioner.delete_machine(action_handler, machine.machine_spec)
-      end
-    when 'update'
-      each_machine(cli_arguments.shift) do |machine, provisioner|
-        machine = provisioner.acquire_machine(action_handler, machine.machine_spec)
-        # TODO find out what files were uploaded so we can do it again
-        machine.setup_convergence(action_handler)
-        machine.converge(action_handler)
-      end
-    when 'stop'
-      each_machine(cli_arguments.shift) do |machine, provisioner|
-        provisioner.stop_machine(action_handler, machine.machine_spec)
-      end
-    when 'cat'
-      each_machine(cli_arguments.shift) do |machine, provisioner|
-        cli_arguments.each do |remote_path|
-          puts machine.read_file(remote_path)
-        end
-      end
-    when 'cp'
-      machines = {}
-      to = cli_arguments.pop
-      if to =~ /^([^\/:]+):(.+)$/
-        to_server = $1
-        machines[to_server] ||= ChefMetal.connect_to_machine(to_server)
-        to_path = $2
-        to_is_directory = machines[to_server].is_directory?(to_path)
-      else
-        to_server = nil
-        to_path = File.absolute_path(to)
-      end
 
-      cli_arguments.each do |from|
-        if from =~ /^([^\/:]+):(.+)$/
-          from_server = $1
-          from_path = $2
-          if to_server
-            raise "Cannot copy from one server to another, or intraserver (from=#{from}, to=#{to})"
+    Cheffish.honor_local_mode do
+      command = cli_arguments.shift
+      case command
+      when 'execute'
+        connect_to_machines(cli_arguments.shift) do |machine|
+          machine.execute(action_handler, cli_arguments.join(' '), :read_only => config[:read_only], :stream => config[:stream], :timeout => config[:timeout].to_f)
+          puts result.stdout if result.stdout != '' && !config[:stream] && Chef::Config.log_level != :debug
+          STDERR.puts result.stderr if result.stderr != '' && !config[:stream] && Chef::Config.log_level != :debug
+          exit_code = result.exitstatus if result.exitstatus != 0
+        end
+      when 'destroy'
+        each_current_machine(cli_arguments.shift) do |driver, specs_and_options|
+          driver.destroy_machines(action_handler, specs_and_options, parallelizer)
+        end
+      when 'allocate'
+        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
+          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
+        end
+      when 'ready'
+        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
+          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
+          driver.ready_machines(action_handler, specs_and_options, parallelizer)
+        end
+      when 'setup'
+        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
+          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
+          driver.ready_machines(action_handler, specs_and_options, parallelizer) do |machine|
+            machine.setup_convergence(action_handler)
           end
-
-          machines[from_server] ||= ChefMetal.connect_to_machine(from_server)
-          if File.directory?(to_path)
-            machines[from_server].download_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
-          else
-            machines[from_server].download_file(action_handler, from_path, to_path)
+        end
+      when 'converge'
+        each_new_machine(cli_arguments.shift) do |driver, specs_and_options|
+          driver.allocate_machines(action_handler, specs_and_options, parallelizer)
+          driver.ready_machines(action_handler, specs_and_options, parallelizer) do |machine|
+            # TODO upload files?  Maybe they should be in machine_options?
+            machine.setup_convergence(action_handler)
+            machine.converge(action_handler)
           end
-        else
-          from_server = nil
-          from_path = File.absolute_path(from)
-          if !to_server
-            raise "Cannot copy two local files.  One of the arguments must be MACHINE:PATH.  (from=#{from}, to=#{to})"
+        end
+      when 'reconverge'
+        connect_to_machines(cli_arguments.shift) do |machine|
+          machine.converge(action_handler)
+        end
+      when 'stop'
+        each_current_machine(cli_arguments.shift) do |driver, specs_and_options|
+          driver.stop_machines(action_handler, specs_and_options, parallelizer)
+        end
+      when 'cat'
+        connect_to_machines(cli_arguments.shift) do |machine|
+          cli_arguments.each do |remote_path|
+            puts machine.read_file(remote_path)
           end
+        end
+      when 'cp'
+        machines = {}
+        to = cli_arguments.pop
+        if to =~ /^([^\/:]+):(.+)$/
+          to_server = $1
+          machines[to_server] ||= ChefMetal.connect_to_machine(to_server)
+          to_path = $2
+          to_is_directory = machines[to_server].is_directory?(to_path)
+        else
+          to_server = nil
+          to_path = File.absolute_path(to)
+        end
 
-          if to_is_directory
-            machines[to_server].upload_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
+        cli_arguments.each do |from|
+          if from =~ /^([^\/:]+):(.+)$/
+            from_server = $1
+            from_path = $2
+            if to_server
+              raise "Cannot copy from one server to another, or intraserver (from=#{from}, to=#{to})"
+            end
+
+            machines[from_server] ||= connect_to_machine(from_server)
+            if File.directory?(to_path)
+              machines[from_server].download_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
+            else
+              machines[from_server].download_file(action_handler, from_path, to_path)
+            end
           else
-            machines[to_server].upload_file(action_handler, from_path, to_path)
+            from_server = nil
+            from_path = File.absolute_path(from)
+            if !to_server
+              raise "Cannot copy two local files.  One of the arguments must be MACHINE:PATH.  (from=#{from}, to=#{to})"
+            end
+
+            if to_is_directory
+              machines[to_server].upload_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
+            else
+              machines[to_server].upload_file(action_handler, from_path, to_path)
+            end
           end
         end
+      else
+        Chef::Log.error("Command '#{command}' unrecognized")
       end
-    else
-      Chef::Log.error("Command '#{command}' unrecognized")
     end
 
-    Chef::Application.destroy_server_connectivity
     exit(exit_code) if exit_code != 0
   end
 
@@ -212,24 +217,47 @@ class ChefMetal::Application < Chef::Application
     @rest ||= Chef::ServerAPI.new()
   end
 
-  def each_machine(spec)
-    spec.split(',').each do |name|
-      yield ChefMetal.connect_to_machine(name)
+  def machine_specs(*specs)
+    names = specs.collect_concat { |spec| spec.split(',') }.uniq
+    parallelizer.parallelize(names) { |name| ChefMetal::ChefMachineSpec.get(name) }.to_a
+  end
+
+  def each_new_machine(spec)
+    driver = ChefMetal.default_driver
+    specs_and_options = {}
+    machine_specs(spec).each do |machine_spec|
+      specs_and_options[machine_spec] = driver.config[:machine_options]
     end
+    [ [ driver,  specs_and_options ] ]
   end
 
-  def action_handler
-    @action_handler ||= ActionHandler.new
+  def each_current_machine(spec)
+    grouped = machine_specs(spec).group_by { |machine_spec| machine_spec.driver_url }
+    parallelizer.parallelize(grouped) do |driver_url, machine_specs|
+      if driver_url
+        driver = ChefMetal.driver_for_url(driver_url)
+        specs_and_options = {}
+        machine_specs(spec).each do |machine_spec|
+          specs_and_options[machine_spec] = driver.config[:machine_options]
+        end
+        yield driver, specs_and_options
+      end
+    end.to_a
   end
 
-  def chef_server
-    {
-      :chef_server_url => Chef::Config[:chef_server_url],
-      :options => {
-        :client_name => Chef::Config[:node_name],
-        :signing_key_filename => Chef::Config[:client_key]
-      }
-    }
+  def connect_to_machines(spec)
+    grouped = machine_specs(spec).group_by { |machine_spec| machine_spec.driver_url }
+    grouped.collect_concat do |driver_url, machine_specs|
+      machine_specs.map { |machine_spec| ChefMetal.connect_to_machine(machine_spec) }
+    end
+  end
+
+  def parallelizer
+    Chef::ChefFS::Parallelizer
+  end
+
+  def action_handler
+    @action_handler ||= ActionHandler.new
   end
 
   class ActionHandler < ChefMetal::ActionHandler

data/lib/chef/provider/machine.rb

@@ -24,12 +24,14 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
   action :ready do
     action_allocate
     machine = current_driver.ready_machine(action_handler, machine_spec, machine_options)
+    machine_spec.save(action_handler)
   end
 
   action :setup do
     machine = action_ready
     begin
       machine.setup_convergence(action_handler)
+      machine_spec.save(action_handler)
       upload_files(machine)
     ensure
       machine.disconnect
@@ -40,6 +42,7 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
     machine = action_ready
     begin
       machine.setup_convergence(action_handler)
+      machine_spec.save(action_handler)
       upload_files(machine)
       # If we were asked to converge, or anything changed, or if a converge has never succeeded, converge.
       if new_resource.converge || (new_resource.converge.nil? && resource_updated?) ||

data/lib/chef/provider/machine_batch.rb

@@ -36,6 +36,7 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
     with_ready_machines do |m|
       prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:resource].name}] ")
       machine[:machine].setup_convergence(prefixed_handler)
+      m[:spec].save(action_handler)
       Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:resource].files)
     end
   end
@@ -44,8 +45,10 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
     with_ready_machines do |m|
       prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:resource].name}] ")
       m[:machine].setup_convergence(prefixed_handler)
+      m[:spec].save(action_handler)
       Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:resource].files)
       m[:machine].converge(prefixed_handler)
+      m[:spec].save(action_handler)
     end
   end
 
@@ -66,6 +69,8 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
     by_id = @machines.inject({}) { |hash,m| hash[m[:spec].id] = m; hash }
     parallel_do(by_new_driver) do |driver, specs_and_options|
       driver.ready_machines(action_handler, specs_and_options, parallelizer) do |machine|
+        machine.machine_spec.save(action_handler)
+
         m = by_id[machine.machine_spec.id]
 
         m[:machine] = machine

data/lib/chef_metal.rb

@@ -30,14 +30,18 @@ module ChefMetal
     @@registered_driver_classes[name] = driver
   end
 
-  def self.config_for_url(driver_url, config = Chef::Config)
+  def self.config_for_url(driver_url, config = Cheffish.profiled_config)
     if config && config[:drivers] && config[:drivers][driver_url]
       config = Cheffish::MergedConfig.new(config[:drivers][driver_url], config)
     end
     config || {}
   end
 
-  def self.driver_for_url(driver_url, config = Chef::Config)
+  def self.default_driver(config = Cheffish.profiled_config)
+    driver_for_url(config[:driver], config)
+  end
+
+  def self.driver_for_url(driver_url, config = Cheffish.profiled_config)
     cluster_type = driver_url.split(':', 2)[0]
     require "chef_metal/driver_init/#{cluster_type}"
     driver_class = @@registered_driver_classes[cluster_type]
@@ -45,7 +49,7 @@ module ChefMetal
     driver_class.from_url(driver_url, config || {})
   end
 
-  def self.connect_to_machine(machine_spec, config = Chef::Config)
+  def self.connect_to_machine(machine_spec, config = Cheffish.profiled_config)
     driver = driver_for_url(machine_spec.driver_url, config)
     if driver
       machine_options = { :convergence_options => { :chef_server => Cheffish.default_chef_server(config) } }

data/lib/chef_metal/driver.rb

@@ -229,7 +229,7 @@ module ChefMetal
       end.to_a
     end
 
-    # Acquire machines in batch, in parallel if possible.
+    # Ready machines in batch, in parallel if possible.
     def ready_machines(action_handler, specs_and_options, parallelizer)
       parallelizer.parallelize(specs_and_options) do |machine_spec, machine_options|
         machine = ready_machine(add_prefix(machine_spec, action_handler), machine_spec, machine_options)
@@ -259,5 +259,9 @@ module ChefMetal
     def add_prefix(machine_spec, action_handler)
       AddPrefixActionHandler.new(action_handler, "[#{machine_spec.name}] ")
     end
+
+    def get_private_key(name)
+      Cheffish.get_private_key(name, config)
+    end
   end
 end

data/lib/chef_metal/machine.rb

@@ -25,6 +25,10 @@ module ChefMetal
       raise "converge not overridden on #{self.class}"
     end
 
+    def cleanup_convergence(action_handler)
+      raise "cleanup_convergence not overridden on #{self.class}"
+    end
+
     def execute(action_handler, command, options = {})
       raise "execute not overridden on #{self.class}"
     end

data/lib/chef_metal/machine/basic_machine.rb

@@ -12,9 +12,6 @@ module ChefMetal
       attr_reader :transport
       attr_reader :convergence_strategy
 
-      # Sets up everything necessary for convergence to happen on the machine.
-      # The machine_spec MUST be saved as part of this procedure.  Other than that,
-      # nothing is guaranteed except that converge() will work when this is done.
       def setup_convergence(action_handler)
         convergence_strategy.setup_convergence(action_handler, self)
       end
@@ -23,6 +20,10 @@ module ChefMetal
         convergence_strategy.converge(action_handler, self)
       end
 
+      def cleanup_convergence(action_handler)
+        convergence_strategy.cleanup_convergence(action_handler, machine_spec)
+      end
+
       def execute(action_handler, command, options = {})
         action_handler.perform_action "run '#{command}' on #{machine_spec.name}" do
           result = transport.execute(command, options)

data/lib/chef_metal/version.rb

@@ -1,3 +1,3 @@
 module ChefMetal
-  VERSION = '0.11.beta.2'
+  VERSION = '0.11.beta.3'
 end

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.11.beta.2
+  version: 0.11.beta.3
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-24 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: net-ssh
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
   name: net-scp
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: net-ssh-gateway
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: inifile
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.beta
+        version: 0.5.beta.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.beta
+        version: 0.5.beta.2
 - !ruby/object:Gem::Dependency
   name: chef-metal-fog
   requirement: !ruby/object:Gem::Requirement
@@ -126,28 +126,28 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A library for creating machines and infrastructures idempotently in Chef.
@@ -160,10 +160,11 @@ extra_rdoc_files:
 - CHANGELOG.md
 - LICENSE
 files:
-- Rakefile
+- CHANGELOG.md
 - LICENSE
 - README.md
-- CHANGELOG.md
+- Rakefile
+- bin/metal
 - lib/chef/provider/machine.rb
 - lib/chef/provider/machine_batch.rb
 - lib/chef/provider/machine_execute.rb
@@ -172,31 +173,30 @@ files:
 - lib/chef/resource/machine_batch.rb
 - lib/chef/resource/machine_execute.rb
 - lib/chef/resource/machine_file.rb
+- lib/chef_metal.rb
 - lib/chef_metal/action_handler.rb
 - lib/chef_metal/add_prefix_action_handler.rb
 - lib/chef_metal/chef_machine_spec.rb
 - lib/chef_metal/chef_provider_action_handler.rb
 - lib/chef_metal/chef_run_data.rb
+- lib/chef_metal/convergence_strategy.rb
 - lib/chef_metal/convergence_strategy/install_cached.rb
 - lib/chef_metal/convergence_strategy/install_msi.rb
 - lib/chef_metal/convergence_strategy/install_sh.rb
 - lib/chef_metal/convergence_strategy/no_converge.rb
 - lib/chef_metal/convergence_strategy/precreate_chef_objects.rb
-- lib/chef_metal/convergence_strategy.rb
 - lib/chef_metal/driver.rb
+- lib/chef_metal/machine.rb
 - lib/chef_metal/machine/basic_machine.rb
 - lib/chef_metal/machine/unix_machine.rb
 - lib/chef_metal/machine/windows_machine.rb
-- lib/chef_metal/machine.rb
 - lib/chef_metal/machine_spec.rb
 - lib/chef_metal/recipe_dsl.rb
+- lib/chef_metal/transport.rb
 - lib/chef_metal/transport/ssh.rb
 - lib/chef_metal/transport/winrm.rb
-- lib/chef_metal/transport.rb
 - lib/chef_metal/version.rb
-- lib/chef_metal.rb
 - spec/integration/machine.rb
-- bin/metal
 homepage: http://wiki.opscode.com/display/chef
 licenses: []
 metadata: {}
@@ -206,17 +206,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A library for creating machines and infrastructures idempotently in Chef.