chef-provisioning-azurerm 0.2.14 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ce684d583f8223fed12875b2a5c20f5d7d2469f
-  data.tar.gz: 03fa0cb67a11529b6e6283260cb1a10450b5cf5d
+  metadata.gz: 7d176236bac9897ee22d2e60033bdfbad9d25796
+  data.tar.gz: 68c52c8d7981aea6e7924cf8d03e3adac0a1583b
 SHA512:
-  metadata.gz: 649403838de5e0117c036b720285f9044c5b346dab7fc858f27c0f50c33cb7047e94f94e2afbb700eb53d576bde0e82bbcfcb62386c2186586ccdb6a73c1a04c
-  data.tar.gz: e5de378badabaf21b4c20868f48b7b9246674492b70b3768cc5c284445826962c9286eb7ff7e797643414c0cab187cb82e66f02481cd1af9343e611e986b5351
+  metadata.gz: 29dd37fd7ed0bc40ad827a7df2e60098c74983ea9b6190c658aecc0b88d2959384299e1461377f38b362aa83c2c5e35cd2476ce59d22f1e14777454295b0bd67
+  data.tar.gz: f7f8969fb4d2782f64a31c23d9d06597d686466516241ca7e523b881e5fcb0e66975e54b5c73b9a07747b34196e7248afc4c8d0563e964e6f185d5f864a8e570

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # chef-provisioning-azurerm Changelog
 
+## [0.3.0] - 2015-09-04
+### Changed
+- Now using ARM functionality from the updated [Azure SDK for Ruby](http://github.com/azure/azure-sdk-for-ruby) rather than direct HTTPS calls to the Resource Manager API.
+- **BREAKING CHANGE** Authentication to Azure must now be via Service Principal, not username and password as previous.  See the [README.md](https://github.com/pendrica/chef-provisioning-azurerm) for more details.
+
 ## [0.2.14] - 2015-08-21
 ### Changed
 - Minimize logging to info, favour action_handler.report_progress

data/README.md

@@ -1,6 +1,6 @@
 # chef-provisioning-azurerm
 
-```chef-provisioning-azurerm``` is a driver for [chef-provisioning](https://github.com/chef/chef-provisioning) that allows Microsoft Azure resources to be provisioned by Chef. This driver uses the new Microsoft Azure Resource Management REST API.
+```chef-provisioning-azurerm``` is a driver for [chef-provisioning](https://github.com/chef/chef-provisioning) that allows Microsoft Azure resources to be provisioned by Chef. This driver uses the new Microsoft Azure Resource Management REST API via the [azure-sdk-for-ruby](https://github.com/azure/azure-sdk-for-ruby).
 
 **current status: prototype/experimental - use at own risk!**
 
@@ -24,23 +24,28 @@ This plugin is distributed as a Ruby Gem. To install it, run:
     
 ### Configuration
 
-For the driver to interact with the Microsoft Azure Resource management REST API, a username and password needs to be configured that refer to an account with the role 'Service Administrator'.
+For the driver to interact with the Microsoft Azure Resource management REST API, a Service Principal needs to be configured with Owner rights against the specific subscription being targeted.  Using an Organization account and related password is no longer supported.  To create a Service Principal and apply the correct permissions, follow the instructions in the article: [Authenticating a service principal with Azure Resource Manager](https://azure.microsoft.com/en-us/documentation/articles/resource-group-authenticate-service-principal/#authenticate-service-principal-with-password---azure-cli)   
 
-*Unlike the Microsoft Azure Service Management API which performs authentication via X.509 v3 certificates, the Resource Management API requires an OAUTH2 authentication token to be passed with each request.  To obtain the token, a username and password is used.*
+You will essentially need 4 parameters from the above article to configure Chef Provisioning: **Subscription ID**, **Client ID**, **Client Secret/Password** and **Tenant ID**.  These can be easily obtained using the azure-cli tools (v0.9.8 or higher) on any platform.
 
 Using a text editor, open or create the file ```~/.azure/credentials``` and add the following section:
 
 ```ruby
 [abcd1234-YOUR-GUID-HERE-abcdef123456]
-username = "username@tenant.onmicrosoft.com"
-password = "your-password-here"
+client_id = "48b9bba3-YOUR-GUID-HERE-90f0b68ce8ba"
+client_secret = "your-client-secret-here"
+tenant_id = "9c117323-YOUR-GUID-HERE-9ee430723ba3"
 ```
 
-The GUID required is that of your Azure subscription.  This can be found after logging into the portal at https://portal.azure.com 
+If preferred, you may also set the following environment variables on the "provisioning node", replacing the values with those obtained when you configured the service principal
 
-**Note:** Storage of the password is required due to the generated access token only being valid for 3600 seconds each time it is generated [1].
+```ruby
+AZURE_CLIENT_ID="48b9bba3-YOUR-GUID-HERE-90f0b68ce8ba"
+AZURE_CLIENT_SECRET="your-client-secret-here"
+AZURE_TENANT_ID="9c117323-YOUR-GUID-HERE-9ee430723ba3"
+```
 
-[1] https://twitter.com/vibronet/status/461260062204239872
+Note that the environment variables, if set, take preference over the values in a configuration file.  The subscription id will be taken from the recipe.
 
 ## Features
 
@@ -53,8 +58,8 @@ To work around the issue of storing chef-provisioning driver info in the Chef se
 The following resources are provided: 
 
 - azure_resource_group
-- azure_storage_account
 - azure_resource_template
+- azure_storage_account
 
 The following resources are planned (note: these resources may be renamed as they are implemented):
 
@@ -89,32 +94,34 @@ For our example, we'll need the azure_deploy.json from [here](https://raw.github
 require 'chef/provisioning/azurerm'
 with_driver 'AzureRM:abcd1234-YOUR-GUID-HERE-abcdef123456'
 
-azure_resource_group 'pendrica-demo-resources' do
+azure_resource_group 'pendrica-demo' do
   location 'West US' # optional, default: 'West US'
   tags businessUnit: 'IT' # optional
 end
 
 azure_resource_template 'my-deployment' do
-  resource_group 'pendrica-demo-resources'
+  resource_group 'pendrica-demo'
   template_source 'cookbooks/provision/files/default/azure_deploy.json'
-  parameters newStorageAccountName: 'penstorage01',
-             adminUsername: 'ubuntu',
+  parameters newStorageAccountName: "mystorageaccount01",
+             adminUsername: 'stuart',
              adminPassword: 'P2ssw0rd',
-             dnsNameForPublicIP: 'pendricatest01',
-             ubuntuOSVersion: '14.04.2-LTS'
+             dnsNameForPublicIP: "my-demo-server",
+             windowsOSVersion: '2012-R2-Datacenter'
   chef_extension client_type: 'ChefClient',
-                 version: '1207.12',
-                 runlist: 'recipe[dscdemo::default]'
+                 version: '1210.12',
+                 runlist: 'role[webserver]'
 end
 ```
 
-**Note: If no chef_extension configuration is specified, the ARM template will imported without enabling the Azure Chef VM Extension**.
+**Note: If no chef_extension configuration is specified, the ARM template will imported without enabling the Azure Chef VM Extension.**
 
 The Chef Server URL, Validation Client name and Validation Key content are not currently exposed parameters but can be overridden via setting the following Chef::Config parameters (via modifying ```c:\chef\client.rb``` or specifying ```-c path\to\client.rb``` on the ```chef-client``` command line). 
 
- - ```Chef::Config[:chef_server_url]```
- - ```Chef::Config[:validation_client_name]```
- - ```Chef::Config[:validation_key]```
+```ruby
+Chef::Config[:chef_server_url]
+Chef::Config[:validation_client_name]
+Chef::Config[:validation_key]
+```
 
 ## Example Recipe 2 - deployment of locally replicated Storage Account
 ### example2.rb
@@ -123,12 +130,12 @@ The Chef Server URL, Validation Client name and Validation Key content are not c
 require 'chef/provisioning/azurerm'
 with_driver 'AzureRM:abcd1234-YOUR-GUID-HERE-abcdef123456'
 
-azure_resource_group 'pendrica-demo-resources' do
+azure_resource_group 'pendrica-demo' do
   location 'West US'
 end
 
-azure_storage_account 'pendevstore01' do
-  resource_group 'pendrica-demo-resources'
+azure_storage_account 'mystorageaccount02' do
+  resource_group 'pendrica-demo'
   location 'West US'
   account_type 'Standard_LRS'
 end

data/lib/chef/provider/azure_resource_group.rb

@@ -9,26 +9,23 @@ class Chef
         true
       end
 
-      def api_url
-        "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-        "#{new_resource.name}?api-version=2015-01-01"
-      end
-
-      # API ref: https://msdn.microsoft.com/en-us/library/azure/dn790525.aspx
       action :create do
         converge_by("create or update Resource Group #{new_resource.name}") do
-          doc = {
-            location: new_resource.location,
-            tags: new_resource.tags
-          }
-          azure_call_until_expected_response(:put, api_url, doc.to_json, '201,200', 60)
+          resource_group = Azure::ARM::Resources::Models::ResourceGroup.new
+          resource_group.location = new_resource.location
+          resource_group.tags = new_resource.tags
+          result = resource_management_client.resource_groups.create_or_update(new_resource.name, resource_group).value!
         end
       end
 
-      # API ref: https://msdn.microsoft.com/en-us/library/azure/dn790539.aspx
       action :destroy do
         converge_by("destroy Resource Group #{new_resource.name}") do
-          azure_call_until_expected_response(:delete, api_url, nil, '404', 60)
+          resource_group_exists = resource_management_client.resource_groups.check_existence(new_resource.name).value!
+          if resource_group_exists.body == "true"
+            result = resource_management_client.resource_groups.delete(new_resource.name).value!
+          else
+            action_handler.report_progress "Resource Group #{new_resource.name} was not found."
+          end
         end
       end
     end

data/lib/chef/provider/azure_resource_template.rb

@@ -9,42 +9,44 @@ class Chef
         true
       end
 
-      # Applies a Resource Manager template to Azure.
-      # If resources of type Microsoft.Compute/virtualMachines are found, a Chef VM Extension is added
-      # Chef VM Extension parameters may be supplied in the recipe.
       action :deploy do
         converge_by("deploy or re-deploy Resource Manager template '#{new_resource.name}'") do
-          template_src_file = ::File.join(Chef::Config[:chef_repo_path], new_resource.template_source)
-          fail "Cannot find file: #{template_src_file}" unless ::File.file?(template_src_file)
-          template_src = ::IO.read(template_src_file)
-          template = JSON.parse(template_src)
-          if new_resource.chef_extension
-            machines = template['resources'].select { |h| h['type'] == 'Microsoft.Compute/virtualMachines' }
-            machines.each do |machine|
-              action_handler.report_progress "Found a compute resource with name: #{machine['name']} and location: #{machine['location']}, adding a Chef VM Extension to it."
-              extension = chef_vm_extension(machine['name'], machine['location'])
-              template['resources'] << JSON.parse(extension)
-            end
+          result = resource_management_client.deployments.create_or_update(new_resource.resource_group, new_resource.name, deployment).value!
+          action_handler.report_progress "Result: #{result.body.properties.provisioning_state}"
+          Chef::Log.debug("result: #{result.body.inspect}")
+          follow_deployment_until_end_state
+        end
+      end
+
+      def deployment
+        deployment = Azure::ARM::Resources::Models::Deployment.new
+        deployment.properties = Azure::ARM::Resources::Models::DeploymentProperties.new
+        deployment.properties.template = template
+        deployment.properties.mode = Azure::ARM::Resources::Models::DeploymentMode::Incremental
+        deployment.properties.parameters = parameters_in_values_format
+        deployment
+      end
+
+      def template
+        template_src_file = ::File.join(Chef::Config[:chef_repo_path], new_resource.template_source)
+        fail "Cannot find file: #{template_src_file}" unless ::File.file?(template_src_file)
+        template = JSON.parse(::IO.read(template_src_file))
+        if new_resource.chef_extension
+          machines = template['resources'].select { |h| h['type'] == 'Microsoft.Compute/virtualMachines' }
+          machines.each do |machine|
+            action_handler.report_progress "adding a Chef VM Extension with name: #{machine['name']} and location: #{machine['location']} "
+            extension = chef_vm_extension(machine['name'], machine['location'])
+            template['resources'] << JSON.parse(extension)
           end
-          Chef::Log.debug("[Azure] Generated template for deployment: #{template}")
-          doc = generate_wrapper_document(template)
-          apply_template_deployment(doc)
-          follow_deployment_until_ended
         end
+        template
       end
 
-      def generate_wrapper_document(template)
+      def parameters_in_values_format
         parameters = new_resource.parameters.map do |key, value|
           { key.to_sym => { 'value' => value } }
         end
-        new_template = {
-          properties: {
-            template: template,
-            mode: 'Incremental',
-            parameters: parameters.reduce(:merge!)
-          }
-        }
-        new_template
+        parameters.reduce(:merge!)
       end
 
       def chef_vm_extension(machine_name, location)
@@ -80,65 +82,36 @@ class Chef
         EOH
       end
 
-      def apply_template_deployment(doc)
-        url = "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-              "#{new_resource.resource_group}/providers/microsoft.resources/deployments/#{new_resource.name}" \
-              '?api-version=2015-01-01'
-        action_handler.report_progress "Posting Resource Template to #{url}.\n"
-        response = azure_call(:put, url, doc.to_json)
-        if response.code.to_i == 200 || response.code.to_i == 201
-          action_handler.report_progress "Accepted Resource Template #{new_resource.name} for deployment.\n"
-        else
-          fail "#{response.body}" if response.body
+      def follow_deployment_until_end_state
+        end_provisioning_states = 'Canceled,Failed,Deleted,Succeeded'
+        end_provisioning_state_reached = false
+        until end_provisioning_state_reached
+          list_outstanding_deployment_operations
+          sleep 5
+          deployment_provisioning_state = deployment_state
+          end_provisioning_state_reached = end_provisioning_states.split(',').include?(deployment_provisioning_state)
         end
+        action_handler.report_progress "Resource Template deployment reached end state of '#{deployment_provisioning_state}'."
       end
 
-      def validate_template_deployment(doc)
-        url = "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-          "#{new_resource.resource_group}/providers/microsoft.resources/deployments/#{new_resource.name}" \
-          '/validate?api-version=2015-01-01'
-        response = azure_call(:post, url, doc.to_json)
-        Chef::Log.info("[Azure] #{response.body.inspect}")
-      end
-
-      # API ref: https://msdn.microsoft.com/en-us/library/azure/dn790565.aspx (Deployment)
-      # API ref: https://msdn.microsoft.com/en-us/library/azure/dn790519.aspx (Operations)
-      def follow_deployment_until_ended
-        url = "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-          "#{new_resource.resource_group}/providers/microsoft.resources/deployments/#{new_resource.name}" \
-          '/operations?api-version=2015-01-01'
-
-        end_provisioning_states = 'Canceled,Failed,Deleted,Succeeded'
+      def list_outstanding_deployment_operations
         end_operation_states = 'Failed,Succeeded'
-        end_provisioning_state_reached = false
-
-        until end_provisioning_state_reached
-          response = azure_call(:get, url, '')
-          Chef::Log.debug("Response body: #{response.body}") if response.body
-          deployment_operations = JSON.parse(response.body)
-          deployment_operations['value'].each do |val|
-            resource_provisioning_state = val['properties']['provisioningState']
-            resource_name = val['properties']['targetResource']['resourceName']
-            resource_type = val['properties']['targetResource']['resourceType']
-            end_operation_state_reached = end_operation_states.split(',').include?(resource_provisioning_state)
-            unless end_operation_state_reached
-              action_handler.report_progress "Resource #{resource_type} '#{resource_name}' provisioning status is #{resource_provisioning_state}\n"
-            end
+        deployment_operations = resource_management_client.deployment_operations.list(new_resource.resource_group, new_resource.name).value!
+        deployment_operations.body.value.each do |val|
+          resource_provisioning_state = val.properties.provisioning_state
+          resource_name = val.properties.target_resource.resource_name
+          resource_type = val.properties.target_resource.resource_type
+          end_operation_state_reached = end_operation_states.split(',').include?(resource_provisioning_state)
+          unless end_operation_state_reached
+            action_handler.report_progress "Resource #{resource_type} '#{resource_name}' provisioning status is #{resource_provisioning_state}\n"
           end
-          sleep 5
-          provisioning_state = retrieve_provisioning_state
-          Chef::Log.debug("[Azure] Resource Template deployment is in a state of '#{provisioning_state}'")
-          end_provisioning_state_reached = end_provisioning_states.split(',').include?(provisioning_state)
         end
-        action_handler.report_progress "Resource Template deployment reached end state of '#{provisioning_state}'."
       end
 
-      def retrieve_provisioning_state
-        url = "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-          "#{new_resource.resource_group}/providers/microsoft.resources/deployments/#{new_resource.name}" \
-          '?api-version=2015-01-01'
-        response = azure_call(:get, url, '')
-        JSON.parse(response.body)['properties']['provisioningState']
+      def deployment_state
+        deployments = resource_management_client.deployments.get(new_resource.resource_group, new_resource.name).value!
+        Chef::Log.debug("deployments result: #{deployments.body.inspect}")
+        deployments.body.properties.provisioning_state
       end
     end
   end

data/lib/chef/provisioning/azurerm.rb

@@ -2,6 +2,8 @@ require 'chef/provisioning'
 require 'chef/provisioning/version'
 require 'chef/provisioning/azurerm/driver'
 require 'chef/provisioning/azurerm/version'
+require 'azure_mgmt_resources'
+
 Chef::Log.info("chef-provisioning-azurerm #{Chef::Provisioning::AzureRM::VERSION}")
 Chef::Log.info("chef-provisioning #{Chef::Provisioning::VERSION}")
 

data/lib/chef/provisioning/azurerm/azure_provider.rb

@@ -12,49 +12,11 @@ class Chef
           @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
         end
 
-        # Makes a call to the specified REST API, adding the Azure bearer token.
-        def azure_call(method, url, data)
-          Chef::Log.debug("HTTP request: #{method} #{url} #{data.to_json}")
-          uri = URI(url)
-          response = nil
-          Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-            case method
-            when :put
-              request = Net::HTTP::Put.new uri
-            when :delete
-              request = Net::HTTP::Delete.new uri
-            when :get
-              request = Net::HTTP::Get.new uri
-            when :post
-              request = Net::HTTP::Post.new uri
-            when :patch
-              request = Net::HTTP::Patch.new uri
-            end
-            request.body = data
-            request['Authorization'] = "Bearer #{new_resource.access_token}"
-            request['Content-Type'] = 'application/json'
-            response = http.request request
-          end
-          response
-        end
-
-        # Wraps a call to the Azure REST API with retry and timeout capability.
-        def azure_call_until_expected_response(method, url, data, success_codes, wait_time)
-          time_elapsed = 0
-          sleep_time = 2
-          max_wait_time = wait_time
-          success_code_found = false
-          while time_elapsed < max_wait_time && !success_code_found
-            response = azure_call(method, url, data)
-            break if response.code.to_i >= 400
-            success_code_found = success_codes.split(',').include?(response.code)
-            break if success_code_found
-            Chef::Log.debug("awaiting success code (#{success_codes}) (got: #{response.code}) - timeout in #{(max_wait_time - time_elapsed)} seconds.")
-            sleep(sleep_time)
-            time_elapsed += sleep_time
-          end
-          Chef::Log.debug("response code: #{response.code} body: #{response.body}")
-          response
+        def resource_management_client
+          credentials = Credentials.new.azure_credentials_for_subscription(new_resource.subscription_id)
+          client = Azure::ARM::Resources::ResourceManagementClient.new(credentials)
+          client.subscription_id = new_resource.subscription_id
+          client
         end
       end
     end

data/lib/chef/provisioning/azurerm/azure_resource.rb

@@ -13,12 +13,10 @@ class Chef
           @driver = run_context.chef_provisioning.current_driver
           fail 'No driver set. (has it been set in your recipe using with_driver?)' unless driver
           @driver_name, @subscription_id = driver.split(':', 2)
-          @access_token = Credentials.new.access_token_for_subscription(@subscription_id)
         end
 
         attr_accessor :driver
         attr_accessor :driver_name
-        attr_accessor :access_token
         attr_accessor :subscription_id
       end
     end

data/lib/chef/provisioning/azurerm/credentials.rb

@@ -4,43 +4,23 @@ class Chef
   module Provisioning
     module AzureRM
       class Credentials
-        AZURE_SERVICE_PRINCIPAL = '1950a258-227b-4e31-a9cf-717495945fc2'
         CONFIG_PATH = "#{ENV['HOME']}/.azure/credentials"
 
         def initialize
           config_file = ENV['AZURE_CONFIG_FILE'] || File.expand_path(CONFIG_PATH)
-          fail "#{CONFIG_PATH} was not found or not accessible." unless File.file?(config_file)
-          @credentials = IniFile.load(File.expand_path(config_file))
-        end
-
-        def access_token_for_subscription(subscription_id)
-          fail "No credentials loaded! Do you have a #{CONFIG_PATH} and a section [#{subscription_id}] within it?" \
-            unless @credentials[subscription_id]
-          fail "No username was found for subscription #{subscription_id}, please verify #{CONFIG_PATH}" \
-            unless @credentials[subscription_id]['username']
-          azure_authenticate(@credentials[subscription_id]['username'], @credentials[subscription_id]['password'])
-        end
-
-        # Do a user_impersonation to get an OAUTH2 access_token for further requests
-        # - Right now this means that the entire recipe must complete with 1 hour
-        # - of the token being issued (NB: the same token can be issued with that hour)
-        def azure_authenticate(username, password)
-          url = 'https://login.windows.net/Common/oauth2/token'
-          data = "resource=https%3A%2F%2Fmanagement.core.windows.net%2F&client_id=#{AZURE_SERVICE_PRINCIPAL}" \
-            "&grant_type=password&username=#{username}&scope=openid&password=#{password}"
-          response = http_post(url, data)
-          JSON.parse(response.body)['access_token']
+          if File.file?(config_file)
+            @credentials = IniFile.load(File.expand_path(config_file))
+          else
+            Chef::Log.warn "#{CONFIG_PATH} was not found or not accessible." unless File.file?(config_file)
+          end
         end
 
-        def http_post(url, data)
-          uri = URI(url)
-          response = nil
-          Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-            request = Net::HTTP::Post.new uri
-            request.body = data
-            response = http.request request
-          end
-          response
+        def azure_credentials_for_subscription(subscription_id)
+          tenant_id = ENV['AZURE_TENANT_ID'] || @credentials[subscription_id]['tenant_id']
+          client_id = ENV['AZURE_CLIENT_ID'] || @credentials[subscription_id]['client_id']
+          client_secret = ENV['AZURE_CLIENT_SECRET'] || @credentials[subscription_id]['client_secret']
+          token_provider = MsRestAzure::ApplicationTokenProvider.new(tenant_id, client_id, client_secret)
+          MsRest::TokenCredentials.new(token_provider)
         end
 
         def self.singleton

data/lib/chef/provisioning/azurerm/version.rb

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module AzureRM
-      VERSION = '0.2.14'
+      VERSION = '0.3.0'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-azurerm
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.3.0
 platform: ruby
 authors:
 - Stuart Preston
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-21 00:00:00.000000000 Z
+date: 2015-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -78,6 +78,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: azure_mgmt_resources
+  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: bundler
   requirement: !ruby/object:Gem::Requirement