knife-cloudstack 0.0.14 → 0.0.15

data/lib/chef/knife/cs_keypair_delete.rb

@@ -0,0 +1,60 @@
+# Copyright:: Copyright (c) 2013 
+# 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/cs_base'
+
+module KnifeCloudstack
+  class CsKeypairDelete < Chef::Knife
+
+    include Chef::Knife::KnifeCloudstackBase
+
+    deps do
+      require 'knife-cloudstack/connection'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cs keypair delete KEY_NAME (options)"
+
+    option :name,
+           :long => "--name NAME",
+           :description => "Specify the ssh keypair name"
+
+    def run
+      validate_base_options
+
+      Chef::Log.debug("Validate keypair name")
+      keypairname = locate_config_value(:name) || @name_args.first
+      unless /^[a-zA-Z0-9][a-zA-Z0-9\-\_]*$/.match(keypairname) then
+          ui.error "Invalid keypairname. Please specify a short name for the keypair"
+          exit 1
+      end
+
+      params = {
+        'command' => 'deleteSSHKeyPair',
+        'name' => keypairname,
+      }
+
+      json = connection.send_request(params)
+
+      unless json['success'] == 'true' then
+        ui.error("Unable to delete SSH Keypair")
+	exit 1
+      end
+      print "#{ui.color("Deleted the SSH Keypair: #{keypairname}", :magenta)}\n"
+    end
+
+  end # class
+end

data/lib/chef/knife/cs_keypair_list.rb

@@ -0,0 +1,83 @@
+# Copyright:: Copyright (c) 2011 Edmunds, Inc.
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# 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/cs_base'
+require 'chef/knife/cs_baselist'
+
+module KnifeCloudstack
+  class CsKeypairList < Chef::Knife
+
+    include Chef::Knife::KnifeCloudstackBase
+    include Chef::Knife::KnifeCloudstackBaseList
+
+    deps do
+      require 'chef/knife'
+      require 'knife-cloudstack/connection'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cs keypair list (options)"
+
+    def run
+      validate_base_options
+	
+      object_list = []
+      object_list << ui.color('Index', :bold) if locate_config_value(:index)
+
+      if locate_config_value(:fields)
+        locate_config_value(:fields).split(',').each { |n| object_list << ui.color(("#{n}").strip, :bold) }
+      else
+        [
+          ui.color('Name', :bold),
+          ui.color('Fingerprint', :bold),
+        ].each { |field| object_list << field }
+      end
+
+      columns = object_list.count
+      object_list = [] if locate_config_value(:noheader)
+
+      connection_result = connection.list_object(
+        "listSSHKeyPairs",
+        "sshkeypair",
+        locate_config_value(:filter),
+        false,
+        locate_config_value(:keyword),
+        locate_config_value(:name)
+      )
+
+      output_format(connection_result)
+ 
+      index_num = 0
+      connection_result.each do |r|
+        if locate_config_value(:index)
+          index_num += 1
+          object_list << index_num.to_s
+        end
+
+        if locate_config_value(:fields)
+          locate_config_value(:fields).downcase.split(',').each { |n| object_list << ((r[("#{n}").strip]).to_s || 'N/A') }
+        else
+          object_list << r['name'].to_s
+          object_list << r['fingerprint'].to_s
+        end
+      end
+      puts ui.list(object_list, :uneven_columns_across, columns)
+      list_object_fields(connection_result) if locate_config_value(:fieldlist)
+    end
+
+  end
+end

data/lib/chef/knife/cs_publicip_list.rb

@@ -0,0 +1,88 @@
+#
+# Author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# 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/cs_base'
+require 'chef/knife/cs_baselist'
+
+module KnifeCloudstack
+  class CsPublicipList < Chef::Knife
+
+    include Chef::Knife::KnifeCloudstackBase
+    include Chef::Knife::KnifeCloudstackBaseList
+
+    deps do
+      require 'knife-cloudstack/connection'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cs publicip list (options)"
+
+    option :listall,
+           :long => "--listall",
+           :description => "List all public ip addresses",
+           :boolean => true
+
+    def run
+      validate_base_options
+
+      if locate_config_value(:fields)
+        object_list = []
+        locate_config_value(:fields).split(',').each { |n| object_list << ui.color(("#{n}").strip, :bold) }
+      else
+        object_list = [
+          ui.color('IP', :bold),
+          ui.color('Account', :bold),
+          ui.color('Domain', :bold),
+          ui.color('Zone', :bold),
+          ui.color('State', :bold),
+          ui.color('Allocated', :bold)
+        ]
+      end
+
+      columns = object_list.count
+      object_list = [] if locate_config_value(:noheader)
+
+      connection_result = connection.list_object(
+        "listPublicIpAddresses",
+        "publicipaddress",
+        locate_config_value(:filter),
+        locate_config_value(:listall),
+        locate_config_value(:keyword),
+        locate_config_value(:name)
+      )
+
+      output_format(connection_result)
+
+      connection_result.each do |r|
+       if locate_config_value(:fields)
+          locate_config_value(:fields).downcase.split(',').each { |n| object_list << ((r[("#{n}").strip]).to_s || 'N/A') }
+        else
+          object_list << r['ipaddress'].to_s
+          object_list << r['account'].to_s
+          object_list << r['domain'].to_s
+          object_list << r['zonename'].to_s
+          object_list << r['state'].to_s
+          object_list << r['allocated'].to_s
+        end
+      end
+      puts ui.list(object_list, :uneven_columns_across, columns)
+      list_object_fields(connection_result) if locate_config_value(:fieldlist)
+    end
+
+  end
+end

data/lib/chef/knife/cs_securitygroup_list.rb

@@ -0,0 +1,134 @@
+#
+# Author:: Ryan Holmes (<rholmes@edmunds.com>)
+# Author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Author:: Sebastien Goasguen (<runseb@gmail.com>)
+# Copyright:: Copyright (c) 2011 Edmunds, Inc.
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# 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/cs_base'
+require 'chef/knife/cs_baselist'
+
+module KnifeCloudstack
+  class CsSecuritygroupList < Chef::Knife
+
+    include Chef::Knife::KnifeCloudstackBase
+    include Chef::Knife::KnifeCloudstackBaseList
+
+    deps do
+      require 'chef/knife'
+      require 'knife-cloudstack/connection'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cs securitygroup list (options)"
+
+    option :name,
+           :long => "--name NAME",
+           :description => "Specify security group to list"
+
+    option :keyword,
+           :long => "--keyword NAME",
+           :description => "Specify part of servicename to list"
+
+    option :index,
+           :long => "--index",
+           :description => "Add index numbers to the output",
+           :boolean => true
+
+    def run
+      validate_base_options
+	
+      object_list = []
+      object_list << ui.color('Index', :bold) if locate_config_value(:index)
+
+      if locate_config_value(:fields)
+        locate_config_value(:fields).split(',').each { |n| object_list << ui.color(("#{n}").strip, :bold) }
+      elsif locate_config_value(:keyword)
+        [
+          ui.color('Name', :bold),
+          ui.color('Description', :bold),
+          ui.color('Account', :bold),
+          ui.color('IngressRules', :bold)
+        ].each { |field| object_list << field }
+      else
+        [
+          ui.color('Name', :bold),
+          ui.color('Description', :bold),
+          ui.color('Account', :bold)
+        ].each { |field| object_list << field }
+      end
+
+      columns = object_list.count
+      object_list = [] if locate_config_value(:noheader)
+
+      connection_result = connection.list_object(
+        "listSecurityGroups",
+        "securitygroup",
+        locate_config_value(:filter),
+        false,
+        locate_config_value(:keyword),
+        locate_config_value(:name)
+      )
+
+      output_format(connection_result)
+            
+      if locate_config_value(:keyword)
+        index_num = 0
+        connection_result['ingressrule'].each do |r|
+          if r.nil?
+          else
+            if locate_config_value(:index)
+              index_num += 1
+              object_list << index_num.to_s
+            end
+
+            if locate_config_value(:fields)
+              locate_config_value(:fields).downcase.split(',').each { |n| object_list << ((r[("#{n}").strip]).to_s || 'N/A') }
+            else
+              object_list << connection_result['name'].to_s
+              object_list << connection_result['description'].to_s
+              object_list << connection_result['account'].to_s
+              object_list << r.to_s         
+            end
+          end  
+        end
+      
+      else
+          index_num = 0
+          connection_result.each do |r|
+            if locate_config_value(:index)
+              index_num += 1
+              object_list << index_num.to_s
+            end
+
+            if locate_config_value(:fields)
+              locate_config_value(:fields).downcase.split(',').each { |n| object_list << ((r[("#{n}").strip]).to_s || 'N/A') }
+            else
+              object_list << r['name'].to_s
+              object_list << r['description'].to_s
+              object_list << r['account'].to_s
+            end
+          end
+      
+      end
+      
+      puts ui.list(object_list, :uneven_columns_across, columns)
+      list_object_fields(connection_result) if locate_config_value(:fieldlist)
+    end
+
+  end
+end

data/lib/chef/knife/cs_server_create.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Ryan Holmes (<rholmes@edmunds.com>)
 # Author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Author:: Sander van Harmelen (<svanharmelen@schubergphilis.com>)
 # Copyright:: Copyright (c) 2011 Edmunds, Inc.
 # Copyright:: Copyright (c) 2013 Sander Botman.
 # License:: Apache License, Version 2.0
@@ -81,6 +82,12 @@ module KnifeCloudstack
            :proc => lambda { |n| n.split(',').map {|sn| sn.strip}} ,
            :default => []
 
+    option :cloudstack_disk,
+           :short => "-D DISK",
+           :long => "--disk DISK",
+           :description => "The CloudStack disk offering name",
+           :proc => Proc.new { |d| Chef::Config[:knife][:cloudstack_disk] = d }
+
     option :cloudstack_hypervisor,
            :long => '--cloudstack-hypervisor HYPERVISOR',
            :description => "The CloudStack hypervisor type for the server"
@@ -169,6 +176,11 @@ module KnifeCloudstack
            :proc => lambda { |o| o.split(/[\s,]+/) },
            :default => []
 
+    option :keypair,
+           :long => "--keypair NAME",
+           :description => "Name of the keypair that should be used to create the vm",
+           :default => false
+
     option :static_nat,
            :long => '--static-nat',
            :description => 'Support Static NAT',
@@ -184,7 +196,7 @@ module KnifeCloudstack
     option :fw_rules,
            :short => "-f PORT_RULES",
            :long => "--fw-rules PORT_RULES",
-           :description => "Comma separated list of firewall rules, e.g. '1024:10000:TCP:192.168.0.0/16,25:25:TCP:10.0.0.0/8'",
+           :description => "Comma separated list of firewall rules, e.g. 'TCP:192.168.0.0/16:1024:65535,TCP::22,UDP::123,ICMP'",
            :proc => lambda { |o| o.split(/[\s,]+/) },
            :default => []
 
@@ -197,6 +209,13 @@ module KnifeCloudstack
            :long => '--fqdn',
            :description => "FQDN which Kerberos Understands (only for Windows Servers)"
 
+    option :set_display_name,
+           :long => '--set-display-name',
+           :description => "Set the same server display name as Chef node name.",
+           :boolean => true,
+           :default => false
+
+
     def run
       validate_base_options
 
@@ -208,6 +227,11 @@ module KnifeCloudstack
       end
       validate_options
 
+      # This little peace of code sets the Chef node-name to the VM name when a node-name is not specifically given
+      unless locate_config_value :chef_node_name
+        Chef::Config[:knife][:chef_node_name] = @name_args.first
+      end
+
       if @windows_image and locate_config_value(:kerberos_realm)
         Chef::Log.debug("Load additional gems for AD/Kerberos Authentication")
         if @windows_platform
@@ -222,18 +246,23 @@ module KnifeCloudstack
       Chef::Log.info("Creating instance with
         service : #{locate_config_value(:cloudstack_service)}
         template : #{locate_config_value(:cloudstack_template)}
+        disk : #{locate_config_value(:cloudstack_disk)}
         zone : #{locate_config_value(:cloudstack_zone)}
         project: #{locate_config_value(:cloudstack_project)}
         network: #{locate_config_value(:cloudstack_networks)}")
 
       print "\n#{ui.color("Waiting for Server to be created", :magenta)}"
-      params = {} 
+      params = {}
       params['hypervisor'] = locate_config_value(:cloudstack_hypervisor) if locate_config_value(:cloudstack_hypervisor)
 
+      params['keypair'] = locate_config_value :keypair  if locate_config_value :keypair
+      params['displayname'] = if locate_config_value :set_display_name and locate_config_value :chef_node_name then locate_config_value :chef_node_name else hostname end
+
       server = connection.create_server(
           hostname,
           locate_config_value(:cloudstack_service),
           locate_config_value(:cloudstack_template),
+          locate_config_value(:cloudstack_disk),
           locate_config_value(:cloudstack_zone),
           locate_config_value(:cloudstack_networks),
           params
@@ -244,7 +273,7 @@ module KnifeCloudstack
       object_fields = []
       object_fields << ui.color("Name:", :cyan)
       object_fields << server['name'].to_s
-      object_fields << ui.color("Name:", :cyan) if locate_config_value(:cloudstack_password)
+      object_fields << ui.color("Password:", :cyan) if locate_config_value(:cloudstack_password)
       object_fields << server['password'] if locate_config_value(:cloudstack_password)
       object_fields << ui.color("Public IP:", :cyan)
       object_fields << public_ip
@@ -256,18 +285,22 @@ module KnifeCloudstack
       return unless config[:bootstrap]
 
       if @bootstrap_protocol == 'ssh'
-        print "\n#{ui.color("Waiting for sshd", :magenta)}"
+        print "\n#{ui.color("Waiting for sshd on: #{public_ip}", :magenta)}"
 
         print(".") until is_ssh_open?(public_ip) {
           sleep BOOTSTRAP_DELAY
           puts "\n"
         }
-      else
-        print "\n#{ui.color("Waiting for winrm to be active", :magenta)}"
+      elsif @bootstrap_protocol == 'winrm'
+        print "\n#{ui.color("Waiting for winrm to be active on: #{public_ip}", :magenta)}"
         print(".") until tcp_test_winrm(public_ip,locate_config_value(:winrm_port)) {
           sleep WINRM_BOOTSTRAP_DELAY
           puts("\n")
         }
+      else
+        puts "Cannot determine the bootstrap protocol."
+        puts "Please specify either ssh or winrm as bootstrap protocol."
+        exit 1
       end
 
       object_fields = []
@@ -293,7 +326,7 @@ module KnifeCloudstack
     end
 
     def is_image_windows?
-        template = connection.get_template(locate_config_value(:cloudstack_template))
+        template = connection.get_template(locate_config_value(:cloudstack_template),locate_config_value(:cloudstack_zone))
         if !template
           ui.error("Template: #{template} does not exist")
           exit 1
@@ -364,6 +397,7 @@ module KnifeCloudstack
     end
 
     def create_port_forwarding_rules(ip_address, server_id, connection)
+      Chef::Log.debug("Creating IP Forwarding Rule")
       rules = locate_config_value(:port_rules)
       if config[:bootstrap]
         if @bootstrap_protocol == 'ssh'
@@ -394,6 +428,7 @@ module KnifeCloudstack
     end
 
     def create_ip_forwarding_rules(ip_address, connection)
+      Chef::Log.debug("Creating IP Forwarding Rule")
       rules = locate_config_value(:ipfwd_rules)
       return unless rules
       rules.each do |rule|
@@ -410,17 +445,33 @@ module KnifeCloudstack
     end
 
     def create_firewall_rules(ip_address, connection)
+      Chef::Log.debug("Creating Firewall Rule")
       rules = locate_config_value(:fw_rules)
       return unless rules
+      icmptype={
+        '0' => {'code' => [0]},
+        '8' => {'code' => [0]},
+        '3' => {'code' => [0, 1]}
+      }
       rules.each do |rule|
         args = rule.split(':')
-        startport = args[0]
-        endport = args[1] || args[0]
-        protocol = args[2] || "TCP"
-        cidr_list = args[3] || "0.0.0.0/0"
-        Chef::Log.debug("Creating Firewall Rule for
+        protocol = args[0]
+        cidr_list = (args[1].nil? || args[1].length == 0) ? "0.0.0.0/0" : args[1]
+        startport = args[2]
+        endport = args[3] || args[2]
+        if protocol == "ICMP"
+          icmptype.each do |type, value|
+            value['code'].each do |code_id|
+              Chef::Log.debug("Creating Firewall Rule for
+                #{ip_address['ipaddress']} with protocol: #{protocol}, icmptype: #{type}, icmpcode: #{code_id}, cidrList: #{cidr_list}")
+              connection.create_firewall_rule(ip_address['id'], protocol, type, code_id, cidr_list)
+            end
+          end
+        else
+          Chef::Log.debug("Creating Firewall Rule for
             #{ip_address['ipaddress']} with protocol: #{protocol}, startport: #{startport}, endport: #{endport}, cidrList: #{cidr_list}")
-        connection.create_firewall_rule(ip_address['id'], protocol, startport, endport, cidr_list)
+          connection.create_firewall_rule(ip_address['id'], protocol, startport, endport, cidr_list)
+        end
       end
     end
 
@@ -516,7 +567,6 @@ module KnifeCloudstack
         ui.error("Unsupported Bootstrapping Protocol. Supported : winrm, ssh")
         exit 1
       end
-      bootstrap.config[:environment] = locate_config_value(:environment)
       bootstrap.config[:chef_node_name] = config[:chef_node_name] || server['id']
       bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
       bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
@@ -529,6 +579,8 @@ module KnifeCloudstack
       bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
       bootstrap.config[:distro] = locate_config_value(:distro)
       bootstrap.config[:template_file] = locate_config_value(:template_file)
+      bootstrap.config[:first_boot_attributes] = locate_config_value(:first_boot_attributes)
+      bootstrap.config[:environment] = locate_config_value(:environment)
       bootstrap
     end
 
@@ -545,7 +597,6 @@ module KnifeCloudstack
       bootstrap.config[:identity_file] = locate_config_value(:identity_file)
       bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || server["name"]
       bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
-      bootstrap.config[:environment] = locate_config_value(:environment)
 
       # may be needed for vpc_mode
       bootstrap.config[:host_key_verify] = config[:host_key_verify]