knife-google 1.3.1 → 2.0.0

data/lib/chef/knife/google_server_delete.rb

@@ -1,4 +1,8 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Author:: Paul Rossman (<paulrossman@google.com>)
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright 2015-2016 Google Inc., 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.
@@ -12,88 +16,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'chef/knife/google_base'
+require "chef/knife"
+require "chef/knife/cloud/server/delete_options"
+require "chef/knife/cloud/server/delete_command"
+require "chef/knife/cloud/google_service"
+require "chef/knife/cloud/google_service_helpers"
+require "chef/knife/cloud/google_service_options"
 
 class Chef
   class Knife
-    class GoogleServerDelete < Knife
-
-      include Knife::GoogleBase
-
-      deps do
-        require 'chef/api_client'
-        require 'google/compute'
-      end
-
-      banner "knife google server delete SERVER [SERVER] -Z ZONE (options)"
-
-      attr_reader :instances
-
-      option :zone,
-        :short => "-Z ZONE",
-        :long => "--gce-zone ZONE",
-        :description => "The Zone for this server"
+    class Cloud
+      class GoogleServerDelete < ServerDeleteCommand
+        include ServerDeleteOptions
+        include GoogleServiceHelpers
+        include GoogleServiceOptions
 
-      option :purge,
-        :short => "-P",
-        :long => "--purge",
-        :boolean => true,
-        :default => false,
-        :description => "Destroy corresponding node and client on the Chef Server, in addition to destroying the GCE server itself. Assumes node and client have the same name as the server (if not, add the '--node-name' option)."
-
-      option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The name of the node and client to delete, if it differs from the server name. Only has meaning when used with the '--purge' option."
-
-      # Taken from knife-ec2 plugin, for rational , check the following link
-      # https://github.com/opscode/knife-ec2/blob/master/lib/chef/knife/ec2_server_delete.rb#L48
-      def destroy_item(klass, name, type_name)
-        begin
-          object = klass.load(name)
-          object.destroy
-          ui.warn("Deleted #{type_name} #{name}")
-        rescue Net::HTTPServerException
-          ui.warn("Could not find a #{type_name} named #{name} to delete!")
-        end
-      end
-
-      def run
-        begin
-          zone = client.zones.get(config[:zone] || Chef::Config[:knife][:gce_zone]).self_link
-        rescue Google::Compute::ResourceNotFound
-          ui.error("Zone '#{config[:zone] || Chef::Config[:knife][:gce_zone]}' not found")
-          exit 1
-        rescue Google::Compute::ParameterValidation
-          ui.error("Must specify zone in knife config file or in command line as an option. Try --help.")
-          exit 1
-        end
+        banner "knife google server delete INSTANCE_NAME [INSTANCE_NAME] (options)"
 
-        @instances = []
-        @name_args.each do |instance_name|
-          begin
-            instance = client.instances.get(:name=>instance_name, :zone=>selflink2name(zone))
-            @instances << instance
-            msg_pair("Name", instance.name)
-            msg_pair("Machine Type", selflink2name(instance.machine_type))
-            msg_pair("Zone", selflink2name(instance.zone))
-            msg_pair("Tags", instance.tags.has_key?("items") ? instance.tags["items"].join(',') : "None")
-            msg_pair("Public IP Address", public_ips(instance).join(','))
-            msg_pair("Private IP Address", private_ips(instance).join(','))
-            puts "\n"
-            ui.warn("Persistent disks attached to this instance are not deleted with this operation")
-            ui.confirm("Do you really want to delete server '#{selflink2name(zone)}:#{instance.name}'")
-            client.instances.delete(:instance=>instance.name, :zone=>selflink2name(zone))
-            ui.warn("Deleted server '#{selflink2name(zone)}:#{instance.name}'")
-            if config[:purge]
-              destroy_item(Chef::Node, instance.name, "node")
-              destroy_item(Chef::ApiClient, instance.name, "client")
-            else
-              ui.warn("Corresponding node and client for the #{instance.name} server were not deleted and remain registered with the Chef Server")
-            end
-          rescue
-            ui.error("Could not locate server '#{selflink2name(zone)}:#{instance_name}'.")
-          end
+        def validate_params!
+          check_for_missing_config_values!
+          super
         end
       end
     end

data/lib/chef/knife/google_server_list.rb

@@ -1,4 +1,8 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Author:: Paul Rossman (<paulrossman@google.com>)
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright 2015-2016 Google Inc., 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.
@@ -11,66 +15,51 @@
 # 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/knife/google_base'
-
-class Chef
-  class Knife
-    class GoogleServerList < Knife
 
-      include Knife::GoogleBase
+require "chef/knife"
+require "chef/knife/cloud/server/list_command"
+require "chef/knife/cloud/server/list_options"
+require "chef/knife/cloud/google_service"
+require "chef/knife/cloud/google_service_helpers"
+require "chef/knife/cloud/google_service_options"
 
-      banner "knife google server list -Z ZONE (options)"
+class Chef::Knife::Cloud
+  class GoogleServerList < ServerListCommand
+    include GoogleServiceHelpers
+    include GoogleServiceOptions
 
-      option :zone,
-        :short => "-Z ZONE",
-        :long => "--gce-zone ZONE",
-        :description => "The Zone for this server"
+    banner "knife google server list"
 
-      def run
-        $stdout.sync = true
-        
-        begin
-          zone = client.zones.get(config[:zone] || Chef::Config[:knife][:gce_zone])
-        rescue Google::Compute::ResourceNotFound
-          ui.error("Zone '#{config[:zone] || Chef::Config[:knife][:gce_zone] }' not found.")
-          exit 1
-        rescue Google::Compute::ParameterValidation
-          ui.error("Must specify zone in knife config file or in command line as an option. Try --help.")
-          exit 1
-        end
+    def validate_params!
+      check_for_missing_config_values!
+      super
+    end
 
-        instance_label = ['name', 'type', 'public ip', 'private ip', 'disks', 'zone', 'status']
-        instance_list = (instance_label.map {|label| ui.color(label, :bold)}).flatten.compact
+    def before_exec_command
+      @columns_with_info = [
+        { label: "Instance Name", key: "name" },
+        { label: "Status",        key: "status", value_callback: method(:format_status_value) },
+        { label: "Machine Type",  key: "machine_type" },
+        { label: "Internal IP",   key: "private_ip" },
+        { label: "External IP",   key: "public_ip" },
+        { label: "Network",       key: "network" },
+      ]
 
-        output_column_count = instance_list.length
+      @sort_by_field = "name"
+    end
 
-        client.instances.list(:zone=>zone.name).each do |instance|
-          instance_list << instance.name
-          instance_list << selflink2name(instance.machine_type.to_s)
-          instance_list << public_ips(instance).join(',')
-          instance_list << private_ips(instance).join(',')
-          instance_list << disks(instance).join(',')
-          instance_list << selflink2name(instance.zone.to_s)
-          instance_list << begin
-            status = instance.status.downcase
-            case status
-            when 'stopping', 'stopped', 'terminated'
-              ui.color(status, :red)
-            when 'requested', 'provisioning', 'staging'
-              ui.color(status, :yellow)
-            else
-              ui.color(status, :green)
-            end
-          end
-        end
+    def format_status_value(status)
+      status = status.downcase
+      status_color = case status
+                     when "stopping", "stopped", "terminated"
+                       :red
+                     when "requested", "provisioning", "staging"
+                       :yellow
+                     else
+                       :green
+                     end
 
-        if instance_list.count > 8  # This condition checks if there are any servers available. The first 8 values are the Labels. 
-           puts ui.list(instance_list, :uneven_columns_across, output_column_count)
-        else
-           puts "No servers found in #{zone.name} zone."
-        end
-      end
+      ui.color(status, status_color)
     end
   end
 end

data/lib/chef/knife/google_server_show.rb

@@ -0,0 +1,44 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright 2016 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/knife"
+require "chef/knife/cloud/server/show_options"
+require "chef/knife/cloud/server/show_command"
+require "chef/knife/cloud/google_service"
+require "chef/knife/cloud/google_service_helpers"
+require "chef/knife/cloud/google_service_options"
+
+class Chef
+  class Knife
+    class Cloud
+      class GoogleServerShow < ServerShowCommand
+        include ServerShowOptions
+        include GoogleServiceHelpers
+        include GoogleServiceOptions
+
+        banner "knife google server show INSTANCE_NAME (options)"
+
+        def validate_params!
+          check_for_missing_config_values!
+          raise "You must supply an instance name to display" if @name_args.empty?
+          raise "You may only supply one instance name" if @name_args.size > 1
+          super
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/google_zone_list.rb

@@ -1,4 +1,8 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Author:: Paul Rossman (<paulrossman@google.com>)
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright 2015-2016 Google Inc., 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.
@@ -11,62 +15,47 @@
 # 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/knife/google_base'
-require 'time'
 
-class Chef
-  class Knife
-    class GoogleZoneList < Knife
+require "chef/knife"
+require "chef/knife/cloud/list_resource_command"
+require "chef/knife/cloud/google_service"
+require "chef/knife/cloud/google_service_helpers"
+require "chef/knife/cloud/google_service_options"
 
-      include Knife::GoogleBase
+class Chef::Knife::Cloud
+  class GoogleZoneList < ResourceListCommand
+    include GoogleServiceHelpers
+    include GoogleServiceOptions
 
-      banner "knife google zone list (options)"
+    banner "knife google zone list"
 
-      def run
-        $stdout.sync = true
+    def validate_params!
+      check_for_missing_config_values!
+      super
+    end
 
-        zone_list = [
-          ui.color("name", :bold),
-          ui.color('status', :bold),
-          ui.color('deprecation', :bold),
-          ui.color('maintainance window', :bold)].flatten.compact
+    def before_exec_command
+      @columns_with_info = [
+        { label: "Zone",   key: "name" },
+        { label: "Status", key: "status", value_callback: method(:format_status_value) },
+      ]
 
-        output_column_count = zone_list.length
+      @sort_by_field = "name"
+    end
+
+    def format_status_value(status)
+      status = status.downcase
+      status_color = if status == "up"
+                       :green
+                     else
+                       :red
+                     end
+
+      ui.color(status, status_color)
+    end
 
-        client.zones.list.each do |zone|
-          zone_list << zone.name
-          zone_list << begin
-            status = zone.status.downcase
-            case status
-            when 'up'
-              ui.color(status, :green)
-            else
-              ui.color(status, :red)
-            end
-          end
-          deprecation_state = "-"
-          if zone.deprecated.respond_to?('state')
-            deprecation_state = zone.deprecated.state  
-          end 
-          zone_list << deprecation_state
-          unless zone.maintenance_windows.nil?
-            maintenance_window = zone.maintenance_windows.map do |mw|
-              begin_time = Time.parse(mw["beginTime"])
-              end_time = Time.parse(mw["endTime"])
-              if (Time.now >= begin_time) and (Time.now <= end_time)
-                ui.color("#{begin_time} to #{end_time}",:red)
-              else
-                ui.color("#{begin_time} to #{end_time}",:green)
-              end
-            end.join(",")
-            zone_list << maintenance_window
-          else
-            zone_list << "-"
-          end
-        end
-        ui.info(ui.list(zone_list, :uneven_columns_across, output_column_count))
-      end
+    def query_resource
+      service.list_zones
     end
   end
 end

data/lib/knife-google/version.rb

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2015 Google Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,6 +14,7 @@
 #
 module Knife
   module Google
-    VERSION = "1.3.1"
+    VERSION = "2.0.0".freeze
+    MAJOR, MINOR, TINY = VERSION.split(".")
   end
 end

data/spec/cloud/google_service_helpers_spec.rb

@@ -0,0 +1,120 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2016 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/knife/cloud/google_service"
+require "chef/knife/cloud/google_service_helpers"
+
+class Tester
+  include Chef::Knife::Cloud::GoogleServiceHelpers
+end
+
+describe Chef::Knife::Cloud::GoogleServiceHelpers do
+  let(:tester) { Tester.new }
+
+  describe '#create_service_instance' do
+    it "creates a GoogleService instance" do
+      expect(tester).to receive(:locate_config_value).with(:gce_project).and_return("test_project")
+      expect(tester).to receive(:locate_config_value).with(:gce_zone).and_return("test_zone")
+      expect(tester).to receive(:locate_config_value).with(:request_timeout).and_return(123)
+      expect(tester).to receive(:locate_config_value).with(:request_refresh_rate).and_return(321)
+      expect(tester).to receive(:locate_config_value).with(:max_pages).and_return(456)
+      expect(tester).to receive(:locate_config_value).with(:max_page_size).and_return(654)
+
+      expect(Chef::Knife::Cloud::GoogleService).to receive(:new).with(
+        project:       "test_project",
+        zone:          "test_zone",
+        wait_time:     123,
+        refresh_rate:  321,
+        max_pages:     456,
+        max_page_size: 654
+      ).and_return("service_object")
+
+      expect(tester.create_service_instance).to eq("service_object")
+    end
+  end
+
+  describe '#check_for_missing_config_values' do
+    it "does not raise an exception if all parameters are present" do
+      expect(tester).to receive(:locate_config_value).with(:gce_project).and_return("project")
+      expect(tester).to receive(:locate_config_value).with(:gce_zone).and_return("zone")
+      expect(tester).to receive(:locate_config_value).with(:key1).and_return("value1")
+      expect(tester).to receive(:locate_config_value).with(:key2).and_return("value2")
+
+      expect { tester.check_for_missing_config_values!(:key1, :key2) }.not_to raise_error
+    end
+
+    it "raises an exception if a parameter is missing" do
+      ui = double("ui")
+      expect(tester).to receive(:ui).and_return(ui)
+      expect(tester).to receive(:locate_config_value).with(:gce_project).and_return("project")
+      expect(tester).to receive(:locate_config_value).with(:gce_zone).and_return(nil)
+      expect(tester).to receive(:locate_config_value).with(:key1).and_return("value1")
+      expect(tester).to receive(:locate_config_value).with(:key2).and_return(nil)
+      expect(ui).to receive(:error).with("The following required parameters are missing: gce_zone, key2")
+      expect { tester.check_for_missing_config_values!(:key1, :key2) }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#private_ip_for' do
+    it "returns the IP address if it exists" do
+      network_interface = double("network_interface", network_ip: "1.2.3.4")
+      server            = double("server", network_interfaces: [network_interface])
+
+      expect(tester.private_ip_for(server)).to eq("1.2.3.4")
+    end
+
+    it "returns 'unknown' if the IP cannot be found" do
+      server = double("server")
+
+      expect(server).to receive(:network_interfaces).and_raise(NoMethodError)
+      expect(tester.private_ip_for(server)).to eq("unknown")
+    end
+  end
+
+  describe '#public_ip_for' do
+    it "returns the IP address if it exists" do
+      access_config     = double("access_config", nat_ip: "4.3.2.1")
+      network_interface = double("network_interface", access_configs: [access_config])
+      server            = double("server", network_interfaces: [network_interface])
+
+      expect(tester.public_ip_for(server)).to eq("4.3.2.1")
+    end
+
+    it "returns 'unknown' if the IP cannot be found" do
+      network_interface = double("network_interface")
+      server            = double("server", network_interfaces: [network_interface])
+
+      expect(network_interface).to receive(:access_configs).and_raise(NoMethodError)
+      expect(tester.public_ip_for(server)).to eq("unknown")
+    end
+  end
+
+  describe '#valid_disk_size?' do
+    it "returns true if the disk is between 10 and 10,000" do
+      expect(tester.valid_disk_size?(50)).to eq(true)
+    end
+
+    it "returns false if the disk is less than 10" do
+      expect(tester.valid_disk_size?(5)).to eq(false)
+    end
+
+    it "returns false if the disk is greater than 10,000" do
+      expect(tester.valid_disk_size?(20_000)).to eq(false)
+    end
+  end
+end