chef-provisioning-fog 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a903c7684ebc84d52a05fb774779952b1769d46
-  data.tar.gz: 22c0d531e5664e6806e34b8401013afd77855125
+  metadata.gz: fb7a20a86bedac40466c9f1ef6f3ffe0e6f8ada8
+  data.tar.gz: e77ef8bf2a3f5a685e43495b4820c1d1c913c461
 SHA512:
-  metadata.gz: 838ce6611ff9ee741f622345a60f8d00244612b11a23d4912e23d432948cc9d11f9ba698fe672a1bee74e2e1830bab9695a6ceafb1234a9e0e0a854def4c5d5b
-  data.tar.gz: 31bbeddadc8045701cfb9e8d45873a99ab033bfe4a8592442a7db1b3fc728c6d09743648640de406da095ed5c2603e8a09496287ead31653e7166b67227f89ff
+  metadata.gz: a1d2ea4273853a0b71603e5b5e36abe234646cdf8d5bc6297bb3d12987988349af74e5f0f83e5df64532c1e8ce9e2058f8178bb17091e34465cc6172b2675334
+  data.tar.gz: e43836b5011677d59a494b3cf94115e9583e284e8f1fd0fce7321084afaf4b6f7bff891928e86af9804dc1916e2b2d95710355bb0fe8481e75a8ec8b49a43a3d

data/README.md

@@ -37,9 +37,9 @@ For example:
 ```ruby
 driver 'fog:AWS:<account_id>:<region>'
 driver_options :compute_options => {
-                                    :aws_access_key_id => 'YOUR-ACCESS-KEY-ID',
-                                    :aws_secret_access_key => 'YOUR-SECRET-ACCESS-KEY',
-                                    :region => 'THE-REGION-YOU-WANT-TO-PROVISION-IN'
+                                     :aws_access_key_id => 'YOUR-ACCESS-KEY-ID',
+                                     :aws_secret_access_key => 'YOUR-SECRET-ACCESS-KEY',
+                                     :region => 'THE-REGION-YOU-WANT-TO-PROVISION-IN'
                                     }
 ```
 
@@ -52,9 +52,9 @@ Update your `knife.rb` to contain your DigitalOcean API token and the driver:
 
 ```ruby
 driver 'fog:DigitalOcean'
-driver_options compute_options: {
-                                  digitalocean_token: 'token'
-                                }
+driver_options :compute_options => {
+                                    :digitalocean_token => 'token'
+                                   }
 ```
 
 For a full example see [examples/digitalocean/simple.rb](examples/digitalocean/simple.rb).
@@ -177,8 +177,19 @@ Docs TODO.
 
 ### XenServer
 
-Docs TODO.
+You should configure XenServer driver with your credentials:
+
+```ruby
+with_driver "fog:XenServer:<XEN-SERVER-IP/NAME>", compute_options: {
+  xenserver_username: 'MY-XEN-USER',
+  xenserver_password: 'MY-XEN-PASSWORD',
+  xenserver_defaults: {
+    'template' => 'ubuntu-14.04'
+  }
+}
+```
 
+For a full example see [examples/xenserver/simple.rb](examples/xenserver/simple.rb).
 
 ### Cleaning up
 

data/lib/chef/provisioning/fog_driver/providers/aws.rb

@@ -134,7 +134,7 @@ module FogDriver
         if machine_options[:is_windows]
           Chef::Log.debug('Attaching WinRM data for user data.')
           # Enable WinRM basic auth, HTTP and open the firewall
-          bootstrap_options[:user_data] = user_data
+          bootstrap_options[:user_data] = user_data if bootstrap_options[:user_data].nil?
         end
         bootstrap_options.delete(:tags) # we handle these separately for performance reasons
         bootstrap_options

data/lib/chef/provisioning/fog_driver/providers/openstack.rb

@@ -18,6 +18,25 @@ module FogDriver
         super(machine_spec, machine_options)
       end
 
+      def create_winrm_transport(machine_spec, machine_options, server)
+        if machine_options[:winrm].nil?
+          fail "You must provide winrm settings in machine_options to use the winrm transport!"
+        end
+        remote_host = determine_remote_host machine_spec, server
+        Chef::Log::info("Connecting to server #{remote_host}")
+        port = machine_options[:winrm][:port] || 5985
+        endpoint = "http://#{remote_host}:#{port}/wsman"
+        type = machine_options[:winrm][:type] || :negotiate
+        decrypted_password = machine_options[:winrm][:password] || ''
+        options = {
+            :user => machine_options[:winrm][:username] || 'Administrator',
+            :pass => decrypted_password,
+            :disable_sspi => !!machine_options[:winrm][:disable_sspi] || false,
+            :basic_auth_only => !!machine_options[:winrm][:basic_auth_only] || false
+        }
+        Chef::Provisioning::Transport::WinRM.new(endpoint, type, options, {})
+      end
+
       def self.compute_options_for(provider, id, config)
         new_compute_options = {}
         new_compute_options[:provider] = provider
@@ -117,6 +136,32 @@ module FogDriver
         end
       end
 
+      def determine_remote_host(machine_spec, server)
+        transport_address_location = (machine_spec.reference['transport_address_location'] || :none).to_sym
+
+        if machine_spec.reference['use_private_ip_for_ssh']
+          # The machine_spec has the old config key, lets update it - a successful chef converge will save the machine_spec
+          # TODO in 2.0 get rid of this update
+          machine_spec.reference.delete('use_private_ip_for_ssh')
+          machine_spec.reference['transport_address_location'] = :private_ip
+          server.private_ip_address
+        elsif transport_address_location == :ip_addresses
+          server.ip_addresses.first
+        elsif transport_address_location == :private_ip
+          server.private_ip_address
+        elsif transport_address_location == :public_ip
+          server.public_ip_address
+        elsif !server.public_ip_address && server.private_ip_address
+          Chef::Log.warn("Server #{machine_spec.name} has no public floating_ip address.  Using private floating_ip '#{server.private_ip_address}'.  Set driver option 'transport_address_location' => :private_ip if this will always be the case ...")
+          server.private_ip_address
+        elsif server.public_ip_address
+          server.public_ip_address
+        else
+          raise "Server #{server.id} has no private or public IP address!"
+          # raise "Invalid 'transport_address_location'.  They can only be 'public_ip', 'private_ip', or 'ip_addresses'."
+        end
+      end
+
     end
   end
 end

data/lib/chef/provisioning/fog_driver/providers/xenserver.rb

@@ -11,6 +11,19 @@ class Chef
             compute_options[:xenserver_username]
           end
 
+          def bootstrap_options_for(action_handler, machine_spec, machine_options)
+            bootstrap_options = super
+            bootstrap_options[:tags] = bootstrap_options[:tags].map {|k,v| "#{k}: #{v}" }
+            bootstrap_options
+          end
+
+          def ssh_options_for(machine_spec, machine_options, server)
+            { auth_methods: [ 'password' ],
+              timeout: (machine_options[:ssh_timeout] || 600),
+              password: machine_options[:ssh_password]
+            }.merge(machine_options[:ssh_options] || {})
+          end
+
           def self.compute_options_for(provider, id, config)
             new_compute_options = {}
             new_compute_options[:provider] = provider
@@ -57,20 +70,22 @@ class Chef
             end
             result
           end
-          
+
           def create_many_servers(num_servers, bootstrap_options, parallelizer)
             parallelizer.parallelize(1.upto(num_servers)) do |i|
-              server = compute.servers.new(bootstrap_options)
-              server.save auto_start: false
+              compute.default_template = bootstrap_options[:template] if bootstrap_options[:template]
+              raise 'No server can be created without a template, please set a template name as bootstrap_options' unless compute.default_template
+              server = compute.default_template.clone bootstrap_options[:name]
 
               if bootstrap_options[:affinity]
                 host = compute.hosts.all.select { |h| h.address == bootstrap_options[:affinity] }.first
                 if !host
                   raise "Host with ID #{bootstrap_options[:affinity]} not found."
                 end
-                server.set_attribute 'affinity', host.reference
+                server.affinity = host.reference
               end
 
+
               unless bootstrap_options[:memory].nil?
                 mem = (bootstrap_options[:memory].to_i * 1024 * 1024).to_s
                 server.set_attribute 'memory_limits', mem, mem, mem, mem
@@ -86,6 +101,13 @@ class Chef
               attrs = {}
               unless bootstrap_options[:network].nil?
                 network = bootstrap_options[:network]
+                net_names = network[:vifs]
+                if net_names
+                  server.vifs.each {|x| x.destroy }
+                  compute.networks.select { |net| Array(net_names).include? net.name }.each do |net|
+                    compute.vifs.create vm: server, network: net, device: "0"
+                  end
+                end
                 attrs['vm-data/ip'] = network[:vm_ip] if network[:vm_ip]
                 attrs['vm-data/gw'] = network[:vm_gateway] if network[:vm_gateway]
                 attrs['vm-data/nm'] = network[:vm_netmask] if network[:vm_netmask]
@@ -96,6 +118,28 @@ class Chef
                 end
               end
 
+              userdevice = 1
+              (bootstrap_options[:additional_disks] || Hash.new).each do |name, data|
+                sr_name = data[:sr]
+                storage_repository = compute.storage_repositories.find { |sr| sr.name == sr_name }
+                raise 'You must specify sr name to add additional disks' unless storage_repository
+                raise 'You must specify size to add additional disk' unless data[:size]
+
+                gb   = 1_073_741_824
+                size = data[:size].to_i * gb
+
+
+                vdi_params = { name: name}
+                vdi_params[:storage_repository] = storage_repository
+                vdi_params[:description] == data[:description] if data[:description]
+                vdi_params[:virtual_size] = size.to_s
+                vdi = compute.vdis.create vdi_params
+
+                compute.vbds.create vm: server, vdi: vdi, userdevice: userdevice.to_s, bootable: false
+                userdevice += 1
+
+              end
+
               server.provision
               yield server if block_given?
               server
@@ -127,31 +171,33 @@ require 'fog/compute/models/server'
 module Fog
   module Compute
     class XenServer
-      class Server < Fog::Compute::Server
-        def id
-          uuid
-        end
+      module Models
+        class Server < Fog::Compute::Server
+          def id
+            uuid
+          end
 
-        def state
-          attributes[:power_state]
-        end
+          def state
+            attributes[:power_state]
+          end
 
-        def public_ip_address
-          if xenstore_data['vm-data/ip']
-            xenstore_data['vm-data/ip']
-          else
-            wait_for { tools_installed? }
-            if tools_installed?
-              guest_metrics.networks.first[1]
+          def public_ip_address
+            if xenstore_data['vm-data/ip']
+              xenstore_data['vm-data/ip']
             else
-              fail 'Unable to return IP address. Virtual machine does not ' \
-              'have XenTools installed or a timeout occurred.'
+              wait_for { tools_installed? }
+              if tools_installed?
+                guest_metrics.networks.first[1]
+              else
+                fail 'Unable to return IP address. Virtual machine does not ' \
+                'have XenTools installed or a timeout occurred.'
+              end
             end
           end
-        end
 
-        def ready?
-          running?
+          def ready?
+            running?
+          end
         end
       end
     end

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

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module FogDriver
-      VERSION = '0.18.0'
+      VERSION = '0.19.0'
     end
   end
 end

data/spec/unit/providers/aws/credentials_spec.rb

@@ -2,7 +2,7 @@ require 'chef/provisioning/fog_driver/providers/aws/credentials'
 
 describe Chef::Provisioning::FogDriver::Providers::AWS::Credentials do
   let(:credentials) { Chef::Provisioning::FogDriver::Providers::AWS::Credentials.new }
-  
+
   describe "#load_inis" do
     let(:aws_credentials_ini_file) { File.join(File.expand_path('../../../../support', __FILE__), 'aws/ini-file.ini') }
 
@@ -15,7 +15,7 @@ describe Chef::Provisioning::FogDriver::Providers::AWS::Credentials do
     end
 
     it "should load the correct values" do
-      expect(credentials['default'][:aws_access_key_id]).to eq "12345"
+      expect(credentials['default'][:aws_access_key_id]).to eq 12345
       expect(credentials['default'][:aws_secret_access_key]).to eq "abcde"
       expect(credentials['default'][:region]).to eq "us-east-1"
       expect(credentials['default'][:aws_session_token]).to eq "mysecret"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-fog
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - John Keiser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-30 00:00:00.000000000 Z
+date: 2016-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-provisioning
@@ -189,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Driver for creating Fog instances in Chef Provisioning.