chef-provisioning-vra 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 498a6b8f2b9524f2dac8bf883e617760799d14f0
+  data.tar.gz: 57ad730009f8f67135296c4268e4f908fe124cdd
+SHA512:
+  metadata.gz: 3212bb8f097d182a244a8e44fa12c503e0002e530939f612379b0d28641a6de4f68ba4165d095fef25765a60b4607bb7a87eff736fac921cde7fb4c7122e2b4a
+  data.tar.gz: dcf354a7c47311dde53312aa429989af49c17511b8817bf5165b4806928506b3cf3b6b8066cc01504ae70da4f97528d59954a5ba41fc40a9183c8e54d17640b2

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,14 @@
+Metrics/AbcSize:
+  Max: 50
+Metrics/ClassLength:
+  Max: 125
+Metrics/LineLength:
+  Max: 130
+Metrics/MethodLength:
+  Max: 25
+Style/Documentation:
+  Enabled: false
+Style/SignalException:
+  Enabled: false
+Style/SpaceInsideBrackets:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chef-provisioning-vra.gemspec
+gemspec
+

data/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

data/README.md

@@ -0,0 +1,123 @@
+# chef-provisioning-vra
+
+Chef Provisioning driver for vRealize Automation
+
+## Configuring and Usage
+
+First, configure Chef Provisioning with your vRA server and authentication information. One option is to place a `driver_options` section in your `knife.rb`:
+
+```ruby
+driver_options username: 'my@email.address',
+               password: 's00pers33cret',
+               tenant: 'vsphere.local',
+               verify_ssl: false,
+               max_wait_time: 1800
+```
+
+`username`, `password`, and `tenant` are required.
+
+`verify_ssl` is optional and defaults to true. If you cannot configure your client or server with trusted certificates, you can set this to false.
+
+`max_wait_time` is the number of seconds to wait for any operation where a request was submitted to vRA and Chef Provisioning must wait for it to complete.  By default, this is 600.
+
+Secondly, in your recipe, configure your bootstrap and transport options for your machine(s).  You can do this using the `with_machine_options` method, or you can pass it directly to each machine's `machine_options` property:
+
+```ruby
+machine_options = {
+  bootstrap_options: {
+    catalog_id: '7bd5f299-8c34-41f6-b63f-c2ac410ee0b6',
+    subtenant_id: 'my_subtenant_uuid',
+    cpus: 1,
+    memory: 1024,
+    requested_for: 'my@email.address',
+    lease_days: 30,
+    key_path: '/path/to/ssh/key'
+  },
+  transport_options: {
+    is_windows: false,
+    username: 'ubuntu',
+  }
+}
+```
+
+### Driver URL
+
+The driver URL should be `vra:https://my-vra-host.com`. Like any other Chef Provisioning driver, you may set this a variety of ways, including the `with_driver` method in your recipe:
+
+```ruby
+with_driver 'vra:https://vra.corp.local' do
+  ... my machines here ...
+end
+```
+
+### Bootstrap Options
+
+The following properties are required:
+
+ * catalog_id
+ * cpus
+ * memory
+ * requested_for
+
+`subtenant_id` is required if your catalog item is a global item and not tied to a specific business group / subtenant.
+
+If you wish to use SSH keys, you must specify a `key_path` or `key_name`.  Failure to specify one of those will cause an error.  If you wish to use password authentication, specify a password in the transport_options.
+
+You may specify additional extra parameters to be passed to the vRA API using the `extra_parameters` property hash:
+
+```ruby
+bootstrap_options: {
+  extra_parameters: {
+    parameter1_name: {
+      type: 'string',
+      value: 'my value'
+    },
+    parameter2_name: {
+      type: 'integer',
+      value: 2
+    }
+  }
+}
+```
+
+### Transport Options
+
+All transport options are optional.
+
+ * `is_windows`: set this to `true` if you are creating a windows machine.  Unfortunately, you must set this manually as vRA does not offer a consistent method for determining this through the API.
+ * `username`: set this to the SSH or WinRM user to use when logging in.  Defaults to `root` on Unix and `Administrator` on Windows.  On Unix, if a non-root user is supplied, Chef Provisioning will attempt to use sudo to gain the required privileges.
+ * `password`:
+   * *Windows*: required.  Set to the user's password to use to log in via WinRM.
+   * *Unix*: optional.  If set, SSH key authentication will not be used.
+
+### Resources
+
+Only the `machine` resource is supported.
+
+## License and Authors
+
+Author:: Chef Partner Engineering (<partnereng@chef.io>)
+
+Copyright:: Copyright (c) 2015 Chef Software, Inc.
+
+License:: Apache License, Version 2.0
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the License at
+
+```
+http://www.apache.org/licenses/LICENSE-2.0
+```
+
+Unless required by applicable law or agreed to in writing, software distributed under the
+License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the specific language governing permissions
+and limitations under the License.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/vmware-vra-gem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/chef-provisioning-vra.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef/provisioning/vra_driver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'chef-provisioning-vra'
+  spec.version       = Chef::Provisioning::VraDriver::VERSION
+  spec.authors       = ['Chef Partner Engineering']
+  spec.email         = ['partnereng@chef.io']
+  spec.summary       = 'A Chef Provisioning driver for VMware vRealize Automation (vRA)'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/chef-partners/chef-provisioning-vra'
+  spec.license       = 'Apache 2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'chef-provisioning'
+  spec.add_dependency 'vmware-vra',            '~> 1.3.0'
+
+  spec.add_development_dependency 'chef',      '>= 12'
+  spec.add_development_dependency 'bundler',   '~> 1.7'
+  spec.add_development_dependency 'rake',      '~> 10.0'
+  spec.add_development_dependency 'rspec',     '~> 3.2'
+end

data/lib/chef/provisioning/driver_init/vra.rb

@@ -0,0 +1,21 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/provisioning/vra_driver/driver'
+
+Chef::Provisioning.register_driver_class('vra', Chef::Provisioning::VraDriver::Driver)

data/lib/chef/provisioning/vra_driver/driver.rb

@@ -0,0 +1,385 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/provisioning/driver'
+require 'chef/provisioning/machine/windows_machine'
+require 'chef/provisioning/machine/unix_machine'
+require 'chef/provisioning/convergence_strategy/install_msi'
+require 'chef/provisioning/convergence_strategy/install_cached'
+require 'chef/provisioning/transport/winrm'
+require 'chef/provisioning/transport/ssh'
+require 'chef/provisioning/vra_driver/version'
+require 'vra'
+
+class Chef
+  module Provisioning
+    module VraDriver
+      class Driver < Chef::Provisioning::Driver # rubocop:disable Metrics/ClassLength
+        attr_reader :base_url
+
+        def self.from_url(driver_url, config)
+          Driver.new(driver_url, config)
+        end
+
+        def self.canonicalize_url(driver_url, config)
+          [ driver_url, config ]
+        end
+
+        def initialize(driver_url, config)
+          super
+
+          _, @base_url = driver_url.split(':', 2)
+        end
+
+        def allocate_machine(action_handler, machine_spec, machine_options)
+          resource = resource_for(machine_spec)
+          return unless resource.nil?
+
+          bootstrap_options = bootstrap_options_for(machine_options)
+          transport_options = transport_options_for(machine_options)
+
+          action_handler.perform_action("Create #{machine_spec.name} with catalog ID #{bootstrap_options[:catalog_id]}") do
+            resource = create_resource(action_handler, machine_spec, machine_options)
+          end
+
+          machine_spec.location = {
+            'driver_url'     => driver_url,
+            'driver_version' => Chef::Provisioning::VraDriver::VERSION,
+            'resource_id'    => resource.id,
+            'allocated_at'   => Time.now.utc.to_s,
+            'is_windows'     => transport_options[:is_windows]
+          }
+        end
+
+        def ready_machine(action_handler, machine_spec, machine_options)
+          resource = resource_for(machine_spec)
+          raise "Unable to locate machine for #{machine_spec.name}" if resource.nil?
+
+          action_handler.report_progress("Powering on #{machine_spec.name} if needed")
+
+          action_handler.perform_action("Power on machine #{machine_spec.name}") do
+            power_on_machine(action_handler, resource)
+          end
+
+          action_handler.report_progress("Waiting for #{machine_spec.name} to be reachable")
+
+          transport = transport_for(machine_spec, machine_options)
+          action_handler.perform_action("Confirm #{machine_spec.name} is reachable") do
+            wait_for(action_handler) { transport.available? }
+          end
+
+          machine_for(machine_spec, machine_options)
+        end
+
+        def stop_machine(action_handler, machine_spec, _machine_options)
+          resource = resource_for(machine_spec)
+          raise "Unable to locate machine for #{machine_spec.name}" if resource.nil?
+
+          action_handler.report_progress("Submitting shutdown / power-off request for #{machine_spec.name}")
+
+          action_handler.perform_action("Powering off machine #{machine_spec.name}") do
+            power_off_machine(action_handler, resource)
+          end
+        end
+
+        def destroy_machine(action_handler, machine_spec, _machine_options)
+          resource = resource_for(machine_spec)
+          return if resource.nil?
+
+          action_handler.report_progress("Submitting destroy request for #{machine_spec.name}")
+
+          action_handler.perform_action("Destroy machine #{machine_spec.name}") do
+            resource.refresh
+
+            destroy_req = resource.destroy
+            wait_for(action_handler) do
+              destroy_req.refresh
+              destroy_req.completed?
+            end
+
+            raise "The vRA request failed: #{destroy_req.completion_details}" if destroy_req.failed?
+          end
+        end
+
+        def connect_to_machine(machine_spec, machine_options)
+          machine_for(machine_spec, machine_options)
+        end
+
+        def description(machine_spec)
+          "X-Chef-Provisioning:#{machine_spec.name}"
+        end
+
+        def resource_for(machine_spec)
+          return nil if machine_spec.location.nil?
+          return @resource if @resource
+
+          begin
+            @resource = vra_client.resources.by_id(machine_spec.location['resource_id'])
+          rescue Vra::Exception::NotFound
+            return nil
+          end
+        end
+
+        def create_resource(action_handler, machine_spec, machine_options)
+          action_handler.report_progress("Submitting catalog request for #{machine_spec.name}")
+
+          submitted_request = catalog_request(machine_spec, machine_options).submit
+          action_handler.report_progress("Catalog request #{submitted_request.id} submitted.")
+
+          wait_for(action_handler) do
+            submitted_request.refresh
+            submitted_request.completed?
+          end
+
+          raise "The vRA request failed: #{submitted_request.completion_details}" if submitted_request.failed?
+
+          servers = submitted_request.resources.select(&:vm?)
+          raise 'The vRA request created more than one server. The catalog blueprint should only return one.' if servers.size > 1
+          raise 'the vRA request did not create any servers.' if servers.size == 0
+
+          servers.first
+        end
+
+        def catalog_request(machine_spec, machine_options)
+          bootstrap_options = bootstrap_options_for(machine_options)
+          catalog_request = vra_client.catalog.request(bootstrap_options[:catalog_id])
+
+          catalog_request.notes         = description(machine_spec)
+          catalog_request.cpus          = bootstrap_options[:cpus]
+          catalog_request.memory        = bootstrap_options[:memory]
+          catalog_request.requested_for = bootstrap_options[:requested_for]
+          catalog_request.lease_days    = bootstrap_options[:lease_days]   unless bootstrap_options[:lease_days].nil?
+          catalog_request.subtenant_id  = bootstrap_options[:subtenant_id] unless bootstrap_options[:subtenant_id].nil?
+
+          if bootstrap_options.key?(:extra_parameters) && bootstrap_options[:extra_parameters].respond_to?(:each)
+            bootstrap_options[:extra_parameters].each do |key, value_data|
+              catalog_request.set_parameter(key, value_data[:type], value_data[:value])
+            end
+          end
+
+          catalog_request
+        end
+
+        def power_on_machine(action_handler, resource)
+          resource.refresh
+          return if resource.machine_on? || resource.machine_turning_on? || resource.machine_in_provisioned_state?
+
+          action_handler.report_progress("Machine status is #{resource.machine_status}. " \
+            "Submitting power-on request for resource #{resource.id}")
+          power_on_req = resource.poweron
+          wait_for(action_handler) do
+            power_on_req.refresh
+            power_on_req.completed?
+          end
+
+          raise "The vRA request failed: #{power_on_req.completion_details}" if power_on_req.failed?
+
+          action_handler.report_progress("Waiting for resource #{resource.id} to be powered on")
+          wait_for(action_handler) do
+            resource.refresh
+            resource.machine_on?
+          end
+        end
+
+        def power_off_machine(action_handler, resource)
+          resource.refresh
+          return if resource.machine_off? || resource.machine_turning_off?
+
+          action_handler.report_progress("Submitting shutdown/power-off request for resource #{resource.id}")
+          begin
+            power_off_req = resource.shutdown
+          rescue Vra::Exception::NotFound
+            power_off_req = resource.poweroff
+          end
+
+          wait_for(action_handler) do
+            power_off_req.refresh
+            power_off_req.completed?
+          end
+
+          raise "The vRA request failed: #{power_off_req.completion_details}" if power_off_req.failed?
+
+          action_handler.report_progress("Waiting for resource #{resource.id} to be powered off")
+          wait_for(action_handler) do
+            resource.refresh
+            resource.machine_off?
+          end
+        end
+
+        def max_wait_time
+          driver_options.fetch(:max_wait_time, 600).to_i
+        end
+
+        def wait_for(action_handler, &block)
+          sleep_time    = 5
+          start_time    = Time.now.utc.to_i
+
+          Timeout.timeout(max_wait_time) do
+            loop do
+              return if block.call == true
+
+              time_elapsed = Time.now.utc.to_i - start_time
+              action_handler.report_progress("been waiting #{time_elapsed}/#{max_wait_time} seconds" \
+                " -- sleeping #{sleep_time} seconds")
+              sleep sleep_time
+            end
+          end
+        end
+
+        def username_for(machine_spec, machine_options, default_username)
+          transport_options = transport_options_for(machine_options)
+
+          machine_spec.reference['username'] || transport_options[:username] || default_username
+        end
+
+        def create_winrm_transport(machine_spec, machine_options, resource)
+          transport_options = transport_options_for(machine_options)
+          remote_host       = remote_host_for(machine_options, resource)
+          username          = username_for(machine_spec, machine_options, 'Administrator')
+          url               = "http://#{remote_host}:5985/wsman"
+          winrm_options     = winrm_options_for(username, transport_options[:password])
+
+          Chef::Provisioning::Transport::WinRM.new(url, :plaintext, winrm_options, config)
+        end
+
+        def winrm_options_for(username, password)
+          auth_type_opt = username.include?('\\') ? :disable_sspi : :basic_auth_only
+
+          {
+            user: username,
+            pass: password,
+            auth_type_opt => true
+          }
+        end
+
+        def create_ssh_transport(machine_spec, machine_options, resource)
+          ssh_options = ssh_options_for(machine_spec, machine_options, resource)
+          remote_host = remote_host_for(machine_options, resource)
+          username    = username_for(machine_spec, machine_options, 'root')
+          options     = ssh_transport_options_for(machine_spec, username)
+
+          Chef::Provisioning::Transport::SSH.new(remote_host, username, ssh_options, options, config)
+        end
+
+        def ssh_transport_options_for(machine_spec, username)
+          options = {}
+          options[:prefix]         = 'sudo ' if use_sudo?(machine_spec, username)
+          options[:ssh_pty_enable] = true
+          options[:ssh_gateway]    = machine_spec.reference['ssh_gateway'] if machine_spec.reference['ssh_gateway']
+
+          options
+        end
+
+        def use_sudo?(machine_spec, username)
+          machine_spec.reference[:sudo] || (!machine_spec.reference.key?(:sudo) && username != 'root')
+        end
+
+        def remote_host_for(machine_options, resource)
+          transport_options = transport_options_for(machine_options)
+          if resource.ip_addresses.empty? || transport_options[:use_hostname]
+            resource.name
+          else
+            resource.ip_addresses.first
+          end
+        end
+
+        def transport_for(machine_spec, machine_options)
+          resource = resource_for(machine_spec)
+
+          if windows?(machine_spec)
+            create_winrm_transport(machine_spec, machine_options, resource)
+          else
+            create_ssh_transport(machine_spec, machine_options, resource)
+          end
+        end
+
+        def machine_for(machine_spec, machine_options)
+          if windows?(machine_spec)
+            Chef::Provisioning::Machine::WindowsMachine.new(machine_spec,
+                                                            transport_for(machine_spec, machine_options),
+                                                            convergence_strategy_for(machine_spec, machine_options))
+          else
+            Chef::Provisioning::Machine::UnixMachine.new(machine_spec,
+                                                         transport_for(machine_spec, machine_options),
+                                                         convergence_strategy_for(machine_spec, machine_options))
+          end
+        end
+
+        def convergence_strategy_for(machine_spec, machine_options)
+          if windows?(machine_spec)
+            Chef::Provisioning::ConvergenceStrategy::InstallMsi.new(machine_options[:convergence_options], config)
+          else
+            Chef::Provisioning::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+          end
+        end
+
+        def ssh_options_for(machine_spec, machine_options, resource)
+          bootstrap_options = bootstrap_options_for(machine_options)
+          transport_options = transport_options_for(machine_options)
+
+          if transport_options.key?(:password)
+            ssh_options = {
+              auth_methods: [ 'password' ],
+              keys_only:    false,
+              password:     transport_options[:password]
+            }
+          else
+            ssh_options = {
+              auth_methods: [ 'publickey' ],
+              keys_only:    true
+            }
+
+            if bootstrap_options[:key_path]
+              ssh_options[:key_data] = [ IO.read(bootstrap_options[:key_path]) ]
+            elsif bootstrap_options[:key_name]
+              ssh_options[:key_data] = [ get_private_key(bootstrap_options[:key_name]) ]
+            else
+              raise "No key found to connect to #{machine_spec.name}" \
+                " - set a key_path or key_name in the machine's bootstrap_options"
+            end
+          end
+
+          ssh_options[:host_key_alias] = "#{resource.id}.vra"
+          ssh_options.merge(machine_options[:ssh_options] || {})
+        end
+
+        def vra_client
+          @vra_client ||= ::Vra::Client.new(
+            base_url:   base_url,
+            username:   driver_options[:username],
+            password:   driver_options[:password],
+            tenant:     driver_options[:tenant],
+            verify_ssl: driver_options[:verify_ssl]
+          )
+        end
+
+        def transport_options_for(machine_options)
+          machine_options.key?(:transport_options) ? machine_options[:transport_options] : {}
+        end
+
+        def bootstrap_options_for(machine_options)
+          machine_options.key?(:bootstrap_options) ? machine_options[:bootstrap_options] : {}
+        end
+
+        def windows?(machine_spec)
+          machine_spec.location['is_windows'] ? true : false
+        end
+      end
+    end
+  end
+end