knife-google 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c84f9e43200cfc6b1555609603026d09b38810a0
-  data.tar.gz: 9f6abcc11414666ce8a37b8fa2ffc5c1dcd177c5
+  metadata.gz: 7fb67127a3cc6cd2859f32160e8b08612eeff968
+  data.tar.gz: 99833b9f9980664e97fb5e2d243fd5ed541f7ee2
 SHA512:
-  metadata.gz: e72acb4b9f20c123a7da556700216f9c21d4469623585c9a5d9f9266160c5c21e1f9aaf3a57777a3c715973d156dd65ad675a3b355edd99424314221ac673afa
-  data.tar.gz: 817ef80036e1a6dce5a2a8400a54d54b2caa2f3c102cc60665427c0509dacaf2186f493c503681c3c0a50d7aeffc1e22a12e6a4f3208fe14a0573e10f14f2b65
+  metadata.gz: bf712c5c7f3b7cc0a4086b04cf5d7db3c27c9f110bfcb56f8e5234faf5688e05711a1fd59d000de4035b8621c7787ff9a87195024fd5122ddc196978b668dd66
+  data.tar.gz: 051a36a7ce5831cbedf78dbcf0179d779a8e18aab4fe9ae7d720443172b7da1df1b132f444ac938927cb06b50b768484e724c98a10f597b07d52b74ba0d42652

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 # knife-google Change Log
 
-## v2.1.0 (2016-03-04
+## v2.2.0 (2016-03-17)
+
+ * [pr#102](https://github.com/chef/knife-google/pull/102) Added support for preemptible instances
+ * [pr#103](https://github.com/chef/knife-google/pull/103) Added support for deploying instances on subnetworks
+ * [pr#103](https://github.com/chef/knife-google/pull/104) Added gcloud-style image aliases (i.e. image "centos-7" will get you the latest CentOS 7 disk image)
+
+## v2.1.0 (2016-03-04)
  * [pr#99](https://github.com/chef/knife-google/pull/99) Support service account scope aliases, similar to the gcloud SDK
  * [pr#101](https://github.com/chef/knife-google/pull/101) Set the application name and version on the API object for proper user-agent formatting
 

data/README.md

@@ -185,7 +185,8 @@ See the [SSH Keys](#ssh-keys) section for more information.
  * **INSTANCE_NAME**: required. The name to use when creating the instance.
  * **--gce-machine-type**: required. The machine type to use when creating the server, such as `n1-standard-2` or `n1-highcpu-2-d`.
  * **--gce-network**: The name of the network to which your instance will be attached. Defaults to "default".
- * **--gce-image**: required. The name of the disk image to use when creating the server. knife-google will search your current project for this disk image. If the image cannot be found but looks like a common public image, the public image project will be searched as well.
+ * **--gce-subnet**: The name of the subnet to which your instance will be attached. Only applies to custom networks.
+ * **--gce-image**: required. The name of the disk image to use when creating the server. knife-google will search your current project for this disk image. If the image cannot be found but looks like a common public image, the public image project will be searched as well. Additionally, this parameter supports the same image aliases that `gcloud compute instances create` supports. See the output of `gcloud compute instances create --help` for a full list of aliases.
     * Example: if you supply a gce-image of `centos-7-v20160219`, knife-google will first look for an image with that name in your currently-configured project. If it cannot be found, it will look in the `centos-cloud` project.
     * This behavior can be overridden with the `--gce-image-project` parameter.
  * **--gce-image-project**: optional. The name of the GCP project that contains the image specified with the `--gce-image` flag. If this is specified, knife-google will not search any known public projects for your image.

data/lib/chef/knife/cloud/google_service.rb

@@ -52,6 +52,27 @@ class Chef::Knife::Cloud
       "userinfo-email"     => "userinfo.email",
     }
 
+    IMAGE_ALIAS_MAP = {
+      "centos-6"           => { project: "centos-cloud",      prefix: "centos-6" },
+      "centos-7"           => { project: "centos-cloud",      prefix: "centos-7" },
+      "container-vm"       => { project: "google-containers", prefix: "container-vm" },
+      "coreos"             => { project: "coreos-cloud",      prefix: "coreos-stable" },
+      "debian-7"           => { project: "debian-cloud",      prefix: "debian-7-wheezy" },
+      "debian-7-backports" => { project: "debian-cloud",      prefix: "backports-debian-7-wheezy" },
+      "debian-8"           => { project: "debian-cloud",      prefix: "debian-8-jessie" },
+      "opensuse-13"        => { project: "opensuse-cloud",    prefix: "opensuse-13" },
+      "rhel-6"             => { project: "rhel-cloud",        prefix: "rhel-6" },
+      "rhel-7"             => { project: "rhel-cloud",        prefix: "rhel-7" },
+      "sles-11"            => { project: "suse-cloud",        prefix: "sles-11" },
+      "sles-12"            => { project: "suse-cloud",        prefix: "sles-12" },
+      "ubuntu-12-04"       => { project: "ubuntu-os-cloud",   prefix: "ubuntu-1204-precise" },
+      "ubuntu-14-04"       => { project: "ubuntu-os-cloud",   prefix: "ubuntu-1404-trusty" },
+      "ubuntu-15-04"       => { project: "ubuntu-os-cloud",   prefix: "ubuntu-1504-vivid" },
+      "ubuntu-15-10"       => { project: "ubuntu-os-cloud",   prefix: "ubuntu-1510-wily" },
+      "windows-2008-r2"    => { project: "windows-cloud",     prefix: "windows-server-2008-r2" },
+      "windows-2012-r2"    => { project: "windows-cloud",     prefix: "windows-server-2012-r2" },
+    }
+
     def initialize(options = {})
       @project       = options[:project]
       @zone          = options[:zone]
@@ -186,12 +207,13 @@ class Chef::Knife::Cloud
     def validate_server_create_options!(options)
       raise "Invalid machine type: #{options[:machine_type]}" unless valid_machine_type?(options[:machine_type])
       raise "Invalid network: #{options[:network]}" unless valid_network?(options[:network])
+      raise "Invalid subnet: #{options[:subnet]}" if options[:subnet] && !valid_subnet?(options[:subnet])
       raise "Invalid Public IP setting: #{options[:public_ip]}" unless valid_public_ip_setting?(options[:public_ip])
-      raise "Invalid image: #{options[:image]} - check your image name, or set an image project if needed" if image_search_for(options[:image], options[:image_project]).nil?
+      raise "Invalid image: #{options[:image]} - check your image name, or set an image project if needed" if boot_disk_source_image(options[:image], options[:image_project]).nil?
     end
 
-    def check_api_call(&block)
-      block.call
+    def check_api_call
+      yield
     rescue Google::Apis::ClientError
       false
     else
@@ -208,6 +230,11 @@ class Chef::Knife::Cloud
       check_api_call { connection.get_network(project, network) }
     end
 
+    def valid_subnet?(subnet)
+      return false if subnet.nil?
+      check_api_call { connection.get_subnetwork(project, region, subnet) }
+    end
+
     def image_exist?(image_project, image_name)
       check_api_call { connection.get_image(image_project, image_name) }
     end
@@ -232,6 +259,10 @@ class Chef::Knife::Cloud
       true
     end
 
+    def region
+      @region ||= connection.get_zone(project, zone).region.split("/").last
+    end
+
     def instance_object_for(options)
       inst_obj                    = Google::Apis::ComputeV1::Instance.new
       inst_obj.name               = options[:name]
@@ -273,7 +304,7 @@ class Chef::Knife::Cloud
       params.disk_name    = boot_disk_name_for(options)
       params.disk_size_gb = options[:boot_disk_size]
       params.disk_type    = disk_type_url_for(boot_disk_type_for(options))
-      params.source_image = image_search_for(options[:image], options[:image_project])
+      params.source_image = boot_disk_source_image(options[:image], options[:image_project])
 
       disk.initialize_params = params
       disk
@@ -283,21 +314,40 @@ class Chef::Knife::Cloud
       options[:boot_disk_ssd] ? "pd-ssd" : "pd-standard"
     end
 
+    def boot_disk_source_image(image, image_project)
+      @boot_disk_source ||= image_search_for(image, image_project)
+    end
+
     def image_search_for(image, image_project)
       # if the user provided an image_project, assume they want it, no questions asked
-      return image_url_for(image_project, image) unless image_project.nil?
+      unless image_project.nil?
+        ui.msg("Searching project #{image_project} for image #{image}")
+        return image_url_for(image_project, image)
+      end
+
+      # no image project has been provided. Check to see if the image is a known alias.
+      alias_url = image_alias_url(image)
+      unless alias_url.nil?
+        ui.msg("image #{image} is a known alias - using image URL: #{alias_url}")
+        return alias_url
+      end
 
-      # no image project has been provided. We'll first check the user's project for the image.
+      # Doesn't match an alias. Let's check the user's project for the image.
       url = image_url_for(project, image)
-      return url unless url.nil?
+      unless url.nil?
+        ui.msg("Located image #{image} in project #{project} - using image URL: #{url}")
+        return url
+      end
 
       # Image not found in user's project. Is there a public project this image might exist in?
       public_project = public_project_for_image(image)
       if public_project
+        ui.msg("Searching public image project #{public_project} for image #{image}")
         return image_url_for(public_project, image)
       end
 
       # No image in user's project or public project, so it doesn't exist.
+      ui.error("Image search failed for image #{image} - no suitable image located")
       nil
     end
 
@@ -305,6 +355,22 @@ class Chef::Knife::Cloud
       return "projects/#{image_project}/global/images/#{image_name}" if image_exist?(image_project, image_name)
     end
 
+    def image_alias_url(image_alias)
+      return unless IMAGE_ALIAS_MAP.key?(image_alias)
+
+      image_project = IMAGE_ALIAS_MAP[image_alias][:project]
+      image_prefix  = IMAGE_ALIAS_MAP[image_alias][:prefix]
+
+      latest_image = connection.list_images(image_project).items
+        .select { |image| image.name.start_with?(image_prefix) }
+        .sort { |a, b| a.name <=> b.name }
+        .last
+
+      return if latest_image.nil?
+
+      latest_image.self_link
+    end
+
     def boot_disk_name_for(options)
       options[:boot_disk_name].nil? ? options[:name] : options[:boot_disk_name]
     end
@@ -331,6 +397,7 @@ class Chef::Knife::Cloud
     def instance_network_interfaces_for(options)
       interface = Google::Apis::ComputeV1::NetworkInterface.new
       interface.network = network_url_for(options[:network])
+      interface.subnetwork = subnet_url_for(options[:subnet]) if options[:subnet]
       interface.access_configs = instance_access_configs_for(options[:public_ip])
 
       Array(interface)
@@ -351,10 +418,15 @@ class Chef::Knife::Cloud
       "projects/#{project}/global/networks/#{network}"
     end
 
+    def subnet_url_for(subnet)
+      "projects/#{project}/regions/#{region}/subnetworks/#{subnet}"
+    end
+
     def instance_scheduling_for(options)
       scheduling = Google::Apis::ComputeV1::Scheduling.new
-      scheduling.automatic_restart = options[:auto_restart].to_s
+      scheduling.automatic_restart   = options[:auto_restart].to_s
       scheduling.on_host_maintenance = migrate_setting_for(options[:auto_migrate])
+      scheduling.preemptible         = options[:preemptible].to_s
 
       scheduling
     end
@@ -466,13 +538,13 @@ class Chef::Knife::Cloud
       items
     end
 
-    def wait_for_status(requested_status, &block)
+    def wait_for_status(requested_status)
       last_status = ""
 
       begin
         Timeout.timeout(wait_time) do
           loop do
-            item = block.call
+            item = yield
             current_status = item.status
 
             if current_status == requested_status

data/lib/chef/knife/google_server_create.rb

@@ -85,6 +85,12 @@ class Chef::Knife::Cloud
       boolean:     true,
       default:     true
 
+    option :preemptible,
+      long:        "--[no-]gce-preemptible",
+      description: "Create the instance as a preemptible instance, allowing GCE to shut it down at any time. Defaults to false.",
+      boolean:     true,
+      default:     false
+
     option :can_ip_forward,
       long:        "--[no-]gce-can-ip-forward",
       description: "Allow server network forwarding",
@@ -96,6 +102,10 @@ class Chef::Knife::Cloud
       description: "The network for this server; default is 'default'",
       default:     "default"
 
+    option :subnet,
+      long:        "--gce-subnet SUBNET",
+      description: "The name of the subnet in the network on which to deploy the instance"
+
     option :tags,
       short:       "-T TAG1,TAG2,TAG3",
       long:        "--gce-tags TAG1,TAG2,TAG3",
@@ -147,9 +157,11 @@ class Chef::Knife::Cloud
         image:                  locate_config_value(:image),
         image_project:          locate_config_value(:image_project),
         network:                locate_config_value(:network),
+        subnet:                 locate_config_value(:subnet),
         public_ip:              locate_config_value(:public_ip),
-        auto_migrate:           locate_config_value(:auto_migrate),
-        auto_restart:           locate_config_value(:auto_restart),
+        auto_migrate:           auto_migrate?,
+        auto_restart:           auto_restart?,
+        preemptible:            preemptible?,
         boot_disk_autodelete:   locate_config_value(:boot_disk_autodelete),
         boot_disk_name:         locate_config_value(:boot_disk_name),
         boot_disk_size:         boot_disk_size,
@@ -177,6 +189,8 @@ class Chef::Knife::Cloud
       raise "Please provide your Google Cloud console email address via --gce-email. " \
         "It is required when resetting passwords on Windows hosts." if locate_config_value(:bootstrap_protocol) == "winrm" && locate_config_value(:gce_email).nil?
 
+      ui.warn("Auto-migrate disabled for preemptible instance") if preemptible? && locate_config_value(:auto_migrate)
+      ui.warn("Auto-restart disabled for preemptible instance") if preemptible? && locate_config_value(:auto_restart)
       super
     end
 
@@ -214,6 +228,18 @@ class Chef::Knife::Cloud
       locate_config_value(:gce_email)
     end
 
+    def preemptible?
+      locate_config_value(:preemptible)
+    end
+
+    def auto_migrate?
+      preemptible? ? false : locate_config_value(:auto_migrate)
+    end
+
+    def auto_restart?
+      preemptible? ? false : locate_config_value(:auto_restart)
+    end
+
     def ip_address_for_bootstrap
       ip = locate_config_value(:use_private_ip) ? private_ip_for(server) : public_ip_for(server)
 

data/lib/knife-google/version.rb

@@ -14,7 +14,7 @@
 #
 module Knife
   module Google
-    VERSION = "2.1.0".freeze
+    VERSION = "2.2.0".freeze
     MAJOR, MINOR, TINY = VERSION.split(".")
   end
 end

data/spec/cloud/google_service_spec.rb

@@ -61,6 +61,7 @@ describe Chef::Knife::Cloud::GoogleService do
   before do
     service.ui = Chef::Knife::UI.new($stdout, $stderr, $stdin, {})
     allow(service.ui).to receive(:msg)
+    allow(service.ui).to receive(:error)
     allow(service).to receive(:connection).and_return(connection)
   end
 
@@ -189,6 +190,7 @@ describe Chef::Knife::Cloud::GoogleService do
       {
         machine_type:  "test_type",
         network:       "test_network",
+        subnet:        "test_subnet",
         public_ip:     "public_ip",
         image:         "test_image",
         image_project: "test_image_project",
@@ -198,6 +200,7 @@ describe Chef::Knife::Cloud::GoogleService do
     before do
       allow(service).to receive(:valid_machine_type?).and_return(true)
       allow(service).to receive(:valid_network?).and_return(true)
+      allow(service).to receive(:valid_subnet?).and_return(true)
       allow(service).to receive(:valid_public_ip_setting?).and_return(true)
       allow(service).to receive(:image_search_for).and_return(true)
     end
@@ -216,6 +219,11 @@ describe Chef::Knife::Cloud::GoogleService do
       expect { service.validate_server_create_options!(options) }.to raise_error(RuntimeError)
     end
 
+    it "raises an exception if the network is not valid" do
+      expect(service).to receive(:valid_subnet?).with("test_subnet").and_return(false)
+      expect { service.validate_server_create_options!(options) }.to raise_error(RuntimeError)
+    end
+
     it "raises an exception if the public ip setting is not valid" do
       expect(service).to receive(:valid_public_ip_setting?).with("public_ip").and_return(false)
       expect { service.validate_server_create_options!(options) }.to raise_error(RuntimeError)
@@ -267,6 +275,20 @@ describe Chef::Knife::Cloud::GoogleService do
     end
   end
 
+  describe '#valid_subnet?' do
+    it "returns false if no subnet was specified" do
+      expect(service.valid_subnet?(nil)).to eq(false)
+    end
+
+    it "checks the network using check_api_call" do
+      expect(service).to receive(:region).and_return("test_region")
+      expect(connection).to receive(:get_subnetwork).with(project, "test_region", "test_subnet")
+      expect(service).to receive(:check_api_call).and_call_original
+
+      service.valid_subnet?("test_subnet")
+    end
+  end
+
   describe '#image_exist?' do
     it "checks the image using check_api_call" do
       expect(connection).to receive(:get_image).with("image_project", "image_name")
@@ -312,6 +334,14 @@ describe Chef::Knife::Cloud::GoogleService do
     end
   end
 
+  describe '#region' do
+    it "returns the region for a given zone" do
+      zone_obj = double("zone_obj", region: "/path/to/test_region")
+      expect(connection).to receive(:get_zone).with(project, zone).and_return(zone_obj)
+      expect(service.region).to eq("test_region")
+    end
+  end
+
   describe '#instance_object_for' do
     let(:instance_object) { double("instance_object") }
     let(:options) do
@@ -453,31 +483,44 @@ describe Chef::Knife::Cloud::GoogleService do
     end
 
     context "when the user does not supply an image project" do
-      context "when the image exists in the user's project" do
-        it "returns the image URL" do
-          expect(service).to receive(:image_url_for).with(project, "test_image").and_return("image_url")
-          expect(service.image_search_for("test_image", nil)).to eq("image_url")
+      context "when the image provided is an alias" do
+        it "returns the alias URL" do
+          expect(service).to receive(:image_alias_url).with("test_image").and_return("image_alias_url")
+          expect(service.image_search_for("test_image", nil)).to eq("image_alias_url")
         end
       end
 
-      context "when the image does not exist in the user's project" do
+      context "when the image provided is not an alias" do
         before do
-          expect(service).to receive(:image_url_for).with(project, "test_image").and_return(nil)
+          expect(service).to receive(:image_alias_url).and_return(nil)
         end
 
-        context "when the image matches a known public project" do
-          it "returns the image URL from the public project" do
-            expect(service).to receive(:public_project_for_image).with("test_image").and_return("public_project")
-            expect(service).to receive(:image_url_for).with("public_project", "test_image").and_return("image_url")
+        context "when the image exists in the user's project" do
+          it "returns the image URL" do
+            expect(service).to receive(:image_url_for).with(project, "test_image").and_return("image_url")
             expect(service.image_search_for("test_image", nil)).to eq("image_url")
           end
         end
 
-        context "when the image does not match a known project" do
-          it "returns nil" do
-            expect(service).to receive(:public_project_for_image).with("test_image").and_return(nil)
-            expect(service).not_to receive(:image_url_for)
-            expect(service.image_search_for("test_image", nil)).to eq(nil)
+        context "when the image does not exist in the user's project" do
+          before do
+            expect(service).to receive(:image_url_for).with(project, "test_image").and_return(nil)
+          end
+
+          context "when the image matches a known public project" do
+            it "returns the image URL from the public project" do
+              expect(service).to receive(:public_project_for_image).with("test_image").and_return("public_project")
+              expect(service).to receive(:image_url_for).with("public_project", "test_image").and_return("image_url")
+              expect(service.image_search_for("test_image", nil)).to eq("image_url")
+            end
+          end
+
+          context "when the image does not match a known project" do
+            it "returns nil" do
+              expect(service).to receive(:public_project_for_image).with("test_image").and_return(nil)
+              expect(service).not_to receive(:image_url_for)
+              expect(service.image_search_for("test_image", nil)).to eq(nil)
+            end
           end
         end
       end
@@ -496,6 +539,50 @@ describe Chef::Knife::Cloud::GoogleService do
     end
   end
 
+  describe '#image_alias_url' do
+    context "when the image_alias is not a valid alias" do
+      it "returns nil" do
+        expect(service.image_alias_url("fake_alias")).to eq(nil)
+      end
+    end
+
+    context "when the image_alias is a valid alias" do
+      before do
+        allow(connection).to receive(:list_images).and_return(response)
+      end
+
+      context "when the response contains no images" do
+        let(:response) { double("response", items: []) }
+
+        it "returns nil" do
+          expect(service.image_alias_url("centos-7")).to eq(nil)
+        end
+      end
+
+      context "when the response contains images but none match the name" do
+        let(:image1)   { double("image1", name: "centos-6") }
+        let(:image2)   { double("image2", name: "centos-6") }
+        let(:image3)   { double("image3", name: "ubuntu-14") }
+        let(:response) { double("response", items: [ image1, image2, image3 ]) }
+
+        it "returns nil" do
+          expect(service.image_alias_url("centos-7")).to eq(nil)
+        end
+      end
+
+      context "when the response contains images that match the name" do
+        let(:image1)   { double("image1", name: "centos-7-v20160201", self_link: "image1_selflink") }
+        let(:image2)   { double("image2", name: "centos-7-v20160301", self_link: "image2_selflink") }
+        let(:image3)   { double("image3", name: "centos-6", self_link: "image3_selflink") }
+        let(:response) { double("response", items: [ image1, image2, image3 ]) }
+
+        it "returns the link for image2 which is the most recent image" do
+          expect(service.image_alias_url("centos-7")).to eq("image2_selflink")
+        end
+      end
+    end
+  end
+
   describe '#boot_disk_name_for' do
     it "returns the boot disk name if supplied by the user" do
       options = { name: "instance_name", boot_disk_name: "disk_name" }
@@ -543,18 +630,50 @@ describe Chef::Knife::Cloud::GoogleService do
   end
 
   describe '#instance_network_interfaces_for' do
-    it "returns an array containing a properly-formatted interface" do
-      interface = double("interface")
-      options   = { network: "test_network", public_ip: "public_ip" }
+    let(:interface) { double("interface" ) }
+    let(:options)   { { network: "test_network", public_ip: "public_ip" } }
 
-      expect(service).to receive(:network_url_for).with("test_network").and_return("network_url")
-      expect(service).to receive(:instance_access_configs_for).with("public_ip").and_return("access_configs")
+    before do
+      allow(service).to receive(:network_url_for)
+      allow(service).to receive(:subnet_url_for)
+      allow(service).to receive(:instance_access_configs_for)
+      allow(Google::Apis::ComputeV1::NetworkInterface).to receive(:new).and_return(interface)
+      allow(interface).to receive(:network=)
+      allow(interface).to receive(:subnetwork=)
+      allow(interface).to receive(:access_configs=)
+    end
 
+    it "creates a network interface object and returns it" do
       expect(Google::Apis::ComputeV1::NetworkInterface).to receive(:new).and_return(interface)
+      expect(service.instance_network_interfaces_for(options)).to eq([interface])
+    end
+
+    it "sets the network" do
+      expect(service).to receive(:network_url_for).with("test_network").and_return("network_url")
       expect(interface).to receive(:network=).with("network_url")
+      service.instance_network_interfaces_for(options)
+    end
+
+    it "sets the access configs" do
+      expect(service).to receive(:instance_access_configs_for).with("public_ip").and_return("access_configs")
       expect(interface).to receive(:access_configs=).with("access_configs")
+      service.instance_network_interfaces_for(options)
+    end
 
-      expect(service.instance_network_interfaces_for(options)).to eq([interface])
+    it "does not set a subnetwork" do
+      expect(service).not_to receive(:subnet_url_for)
+      expect(interface).not_to receive(:subnetwork=)
+      service.instance_network_interfaces_for(options)
+    end
+
+    context "when a subnet exists" do
+      let(:options) { { network: "test_network", subnet: "test_subnet", public_ip: "public_ip" } }
+
+      it "sets the subnetwork" do
+        expect(service).to receive(:subnet_url_for).with("test_subnet").and_return("subnet_url")
+        expect(interface).to receive(:subnetwork=).with("subnet_url")
+        service.instance_network_interfaces_for(options)
+      end
     end
   end
 
@@ -564,15 +683,23 @@ describe Chef::Knife::Cloud::GoogleService do
     end
   end
 
+  describe '#subnet_url_for' do
+    it "returns a properly-formatted subnet URL" do
+      expect(service).to receive(:region).and_return("test_region")
+      expect(service.subnet_url_for("test_subnet")).to eq("projects/test_project/regions/test_region/subnetworks/test_subnet")
+    end
+  end
+
   describe '#instance_scheduling_for' do
     it "returns a properly-formatted scheduling object" do
       scheduling = double("scheduling")
-      options    = { auto_restart: "auto_restart", auto_migrate: "auto_migrate" }
+      options    = { auto_restart: "auto_restart", auto_migrate: "auto_migrate", preemptible: "preempt" }
 
       expect(service).to receive(:migrate_setting_for).with("auto_migrate").and_return("host_maintenance")
       expect(Google::Apis::ComputeV1::Scheduling).to receive(:new).and_return(scheduling)
       expect(scheduling).to receive(:automatic_restart=).with("auto_restart")
       expect(scheduling).to receive(:on_host_maintenance=).with("host_maintenance")
+      expect(scheduling).to receive(:preemptible=).with("preempt")
 
       expect(service.instance_scheduling_for(options)).to eq(scheduling)
     end

data/spec/google_server_create_spec.rb

@@ -38,8 +38,13 @@ describe Chef::Knife::Cloud::GoogleServerCreate do
       allow(command).to receive(:check_for_missing_config_values!)
       allow(command).to receive(:valid_disk_size?).and_return(true)
       allow(command).to receive(:boot_disk_size)
-      command.config[:bootstrap_protocol] = "ssh"
-      command.config[:identity_file] = "/path/to/file"
+      allow(command).to receive(:locate_config_value).with(:bootstrap_protocol).and_return("ssh")
+      allow(command).to receive(:locate_config_value).with(:identity_file).and_return("/path/to/file")
+      allow(command).to receive(:locate_config_value).with(:auto_migrate)
+      allow(command).to receive(:locate_config_value).with(:auto_restart)
+      allow(command).to receive(:locate_config_value).with(:chef_node_name)
+      allow(command).to receive(:locate_config_value).with(:chef_node_name_prefix)
+      allow(command).to receive(:preemptible?).and_return(false)
     end
 
     context "when no instance name has been provided" do
@@ -66,6 +71,20 @@ describe Chef::Knife::Cloud::GoogleServerCreate do
       expect(command).to receive(:locate_config_value).with(:gce_email).and_return(nil)
       expect { command.validate_params! }.to raise_error(RuntimeError)
     end
+
+    it "prints a warning if auto-migrate is true for a preemptible instance" do
+      allow(command).to receive(:preemptible?).and_return(true)
+      allow(command).to receive(:locate_config_value).with(:auto_migrate).and_return(true)
+      expect(command.ui).to receive(:warn).with("Auto-migrate disabled for preemptible instance")
+      command.validate_params!
+    end
+
+    it "prints a warning if auto-restart is true for a preemptible instance" do
+      allow(command).to receive(:preemptible?).and_return(true)
+      allow(command).to receive(:locate_config_value).with(:auto_restart).and_return(true)
+      expect(command.ui).to receive(:warn).with("Auto-restart disabled for preemptible instance")
+      command.validate_params!
+    end
   end
 
   describe '#before_bootstrap' do
@@ -133,6 +152,39 @@ describe Chef::Knife::Cloud::GoogleServerCreate do
     end
   end
 
+  describe '#preemptible?' do
+    it "returns the preemptible setting from the config" do
+      expect(command).to receive(:locate_config_value).with(:preemptible).and_return("test_preempt")
+      expect(command.preemptible?).to eq("test_preempt")
+    end
+  end
+
+  describe '#auto_migrate?' do
+    it "returns false if the instance is preemptible" do
+      expect(command).to receive(:preemptible?).and_return(true)
+      expect(command.auto_migrate?).to eq(false)
+    end
+
+    it "returns the setting from the config if preemptible is false" do
+      expect(command).to receive(:preemptible?).and_return(false)
+      expect(command).to receive(:locate_config_value).with(:auto_migrate).and_return("test_migrate")
+      expect(command.auto_migrate?).to eq("test_migrate")
+    end
+  end
+
+  describe '#auto_restart?' do
+    it "returns false if the instance is preemptible" do
+      expect(command).to receive(:preemptible?).and_return(true)
+      expect(command.auto_restart?).to eq(false)
+    end
+
+    it "returns the setting from the config if preemptible is false" do
+      expect(command).to receive(:preemptible?).and_return(false)
+      expect(command).to receive(:locate_config_value).with(:auto_restart).and_return("test_restart")
+      expect(command.auto_restart?).to eq("test_restart")
+    end
+  end
+
   describe '#ip_address_for_bootstrap' do
     it "returns the public IP by default" do
       expect(command).to receive(:locate_config_value).with(:use_private_ip).and_return(false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-google
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Chiraq Jog
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-04 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef