knife-cloudstack 0.0.15 → 0.0.16

data/lib/chef/knife/cs_server_create.rb

@@ -103,6 +103,10 @@ module KnifeCloudstack
            :boolean => true,
            :default => true
 
+    option :ik_private_ip,
+           :long => "--private-ip PRIVATE_IPV4_ADDRESS",
+           :description => "Pass a certain private ipv4 address to cloudstack when deploying (only supported on isolated networks)"
+
     option :chef_node_name,
            :short => "-N NAME",
            :long => "--node-name NAME",
@@ -128,6 +132,14 @@ module KnifeCloudstack
            :long => "--identity-file IDENTITY_FILE",
            :description => "The SSH identity file used for authentication"
 
+    option :secret_file,
+           :long => "--secret-file SECRET_FILE",
+           :description => "The path to the file that contains the encryption key."
+
+    option :secret,
+           :long => "--secret SECRET",
+           :description => "The encryption key that is used for values contained within a data bag item."
+
     option :prerelease,
            :long => "--prerelease",
            :description => "Install the pre-release chef gems"
@@ -257,6 +269,7 @@ module KnifeCloudstack
 
       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
+      params['ipaddress'] = locate_config_value(:ik_private_ip) if locate_config_value(:ik_private_ip) 
 
       server = connection.create_server(
           hostname,
@@ -268,6 +281,10 @@ module KnifeCloudstack
           params
       )
 
+      zone_name = locate_config_value(:cloudstack_zone)
+      zone = zone_name ? connection.get_zone(zone_name) : connection.get_default_zone
+
+      config[:public_ip] = false if zone['networktype'] == 'Basic'
       public_ip = find_or_create_public_ip(server, connection)
 
       object_fields = []
@@ -326,9 +343,11 @@ module KnifeCloudstack
     end
 
     def is_image_windows?
-        template = connection.get_template(locate_config_value(:cloudstack_template),locate_config_value(:cloudstack_zone))
+        template_name = locate_config_value(:cloudstack_template)
+        template = connection.get_template(template_name, locate_config_value(:cloudstack_zone))
+        template = connection.get_iso(template_name, locate_config_value(:cloudstack_zone)) unless template
         if !template
-          ui.error("Template: #{template} does not exist")
+          ui.error("Template: #{template_name} does not exist!")
           exit 1
         end
         return template['ostypename'].scan('Windows').length > 0
@@ -376,7 +395,6 @@ module KnifeCloudstack
 
     def find_or_create_public_ip(server, connection)
       nic = connection.get_server_default_nic(server) || {}
-      #puts "#{ui.color("Not allocating public IP for server", :red)}" unless config[:public_ip]
       if (config[:public_ip] == false)
         nic['ipaddress']
       else
@@ -398,7 +416,7 @@ module KnifeCloudstack
 
     def create_port_forwarding_rules(ip_address, server_id, connection)
       Chef::Log.debug("Creating IP Forwarding Rule")
-      rules = locate_config_value(:port_rules)
+      rules = locate_config_value(:port_rules) || []
       if config[:bootstrap]
         if @bootstrap_protocol == 'ssh'
           rules += ["#{locate_config_value(:ssh_port)}"] #SSH Port
@@ -409,7 +427,7 @@ module KnifeCloudstack
           exit 1
         end
       end
-      return unless rules
+      return if rules.empty?
       rules.each do |rule|
         args = rule.split(':')
         public_port = args[0]
@@ -595,6 +613,8 @@ module KnifeCloudstack
       locate_config_value(:cloudstack_password) ? bootstrap.config[:ssh_password] = server['password'] : bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
       bootstrap.config[:ssh_port] = locate_config_value(:ssh_port) || 22
       bootstrap.config[:identity_file] = locate_config_value(:identity_file)
+      bootstrap.config[:secret_file] = locate_config_value(:secret_file)
+      bootstrap.config[:secret] = locate_config_value(:secret)
       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'
 

data/lib/chef/knife/cs_server_list.rb

@@ -18,21 +18,14 @@
 # limitations under the License.
 #
 
-require 'chef/knife/cs_base'
+require 'chef/knife'
 require 'chef/knife/cs_baselist'
 
 module KnifeCloudstack
   class CsServerList < 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 server list (options)"
 
     option :listall,
@@ -52,66 +45,46 @@ module KnifeCloudstack
            :short => "-a ACTION",
            :long => "--action ACTION",
            :description => "start, stop or destroy the instances in your result"
+           
+    option :public_ip,
+           :long => "--[no-]public-ip",
+           :description => "Show or don't show the public IP for server in your result",
+           :boolean => true,
+           :default => 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('Name', :bold),
-          ui.color('Public IP', :bold),
-          ui.color('Service', :bold),
-          ui.color('Template', :bold),
-          ui.color('State', :bold),
-          ui.color('Instance', :bold),
-          ui.color('Hypervisor', :bold)
-        ]
-      end
-
-      columns = object_list.count
-      object_list = [] if locate_config_value(:noheader)
-
-      connection_result = connection.list_object(
-        "listVirtualMachines",
-        "virtualmachine",
-        locate_config_value(:filter),
-        locate_config_value(:listall),
-        locate_config_value(:keyword),
-        locate_config_value(:name)
-      )
-
-      output_format(connection_result)
-
-      rules = connection.list_port_forwarding_rules(nil, true)
+ 
+      columns = [
+        'Name       :name',
+        'Public IP  :ipaddress',
+        'Service    :serviceofferingname',
+        'Template   :templatename',
+        'State      :state',
+        'Instance   :instancename',
+        'Hypervisor :hostname'
+      ]
+
+      params = { 'command' => "listVirtualMachines" }
+      params['filter']  = locate_config_value(:filter)  if locate_config_value(:filter)
+      params['listall'] = locate_config_value(:listall) if locate_config_value(:listall)
+      params['keyword'] = locate_config_value(:keyword) if locate_config_value(:keyword)
+      params['name']    = locate_config_value(:name)    if locate_config_value(:name)
+      
+      ##
+      # Get the public IP address if possible, except when the option --no-public-ip is given.
+
+      rules       = connection.list_port_forwarding_rules(nil, true)
       public_list = connection.list_public_ip_addresses(true)
-
-
-      connection_result.each do |r|
-        name = r['name']
-        display_name = r['displayname']
-        if display_name && !display_name.empty? && display_name != name
-          name << " (#{display_name})"
-        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']
-          r['nic'].empty? ? object_list << "N/A" : object_list << (connection.get_server_public_ip(r, rules, public_list) || '')
-          object_list << r['serviceofferingname']
-          object_list << r['templatename']
-          object_list << r['state']
-          object_list << (r['instancename'] || 'N/A')
-          object_list << (r['hostname'] || 'N/A')
-        end
+      result      = connection.list_object(params, "virtualmachine")
+      result.each do |n|
+        public_ip = connection.get_server_public_ip(n, rules, public_list) if locate_config_value(:public_ip)
+        private_ip = (n['nic'].select { |k| k['isdefault'] }).first
+        public_ip ? n['ipaddress'] = public_ip : n['ipaddress'] = private_ip['ipaddress'] || "N/A"
       end
 
-      puts ui.list(object_list, :uneven_columns_across, columns)
-      list_object_fields(connection_result) if locate_config_value(:fieldlist)
-
+      list_object(columns, result)
+      
       ## 
       # Executing actions against the list results that are returned.
 

data/lib/chef/knife/cs_server_remove_nic.rb

@@ -0,0 +1,101 @@
+#
+# Author:: John E. Vincent (<lusis.org+github.com@gmail.com>)
+# Copyright:: Copyright (c) 2013 John E. Vincent
+# 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 CsServerRemoveNic < Chef::Knife
+
+    include Chef::Knife::KnifeCloudstackBase
+    include Chef::Knife::KnifeCloudstackBaseList
+
+    deps do
+      require 'knife-cloudstack/connection'
+      require 'chef/knife'
+      Chef::Knife.load_deps
+    end
+
+    banner "knife cs server remove nic SERVERID NICID"
+
+
+    def run
+      validate_base_options
+
+      @server_id, @nic_id = name_args
+
+      if @server_id.nil? || @nic_id.nil?
+        show_usage
+        ui.fatal("You must provide both a nic id and a server id")
+        exit(1)
+      end
+
+
+      object_list = []
+      if locate_config_value(:fields)
+        locate_config_value(:fields).split(',').each { |n| object_list << ui.color(("#{n}").strip, :bold) }
+      else
+        object_list << ui.color('Server', :bold)
+        object_list << ui.color('Network', :bold)
+        object_list << ui.color('Type', :bold)
+        object_list << ui.color('Default', :bold)
+        object_list << ui.color('Address', :bold)
+        object_list << ui.color('Gateway', :bold)
+        object_list << ui.color('Netmask', :bold)
+        object_list << ui.color('ID', :bold)
+      end
+
+      columns = object_list.count
+
+      connection_result = connection.remove_nic_from_vm(
+        @nic_id,
+        @server_id
+      )
+
+      output_format(connection_result)
+
+      object_list << connection_result['name']
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      object_list << ''
+      if connection_result['nic']
+        connection_result['nic'].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 << ''
+              object_list << r['networkname'].to_s
+              object_list << r['type'].to_s
+              object_list << (r['isdefault'] ? r['isdefault'].to_s : 'false')
+              object_list << (r['ipaddress'] || '')
+              object_list << (r['gateway'] || '')
+              object_list << (r['netmask'] || '')
+              object_list << (r['networkid'] || '')
+            end
+        end
+        puts ui.list(object_list, :uneven_columns_across, columns)
+        list_object_fields(connection_result) if locate_config_value(:fieldlist)
+      else
+        ui.error("No nics returned in response")
+      end
+    end
+  end
+end

data/lib/chef/knife/cs_service_list.rb

@@ -18,21 +18,14 @@
 # limitations under the License.
 #
 
-require 'chef/knife/cs_base'
+require 'chef/knife'
 require 'chef/knife/cs_baselist'
 
 module KnifeCloudstack
   class CsServiceList < 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 service list (options)"
 
     option :name,
@@ -43,62 +36,29 @@ module KnifeCloudstack
            :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) }
-      else
-        [
-          ui.color('Name', :bold),
-          ui.color('Memory', :bold),
-          ui.color('CPUs', :bold),
-          ui.color('CPU Speed', :bold),
-          ui.color('Created', :bold)
-        ].each { |field| object_list << field }
+      columns = [
+        'Name      :name',
+        'Memory    :memory',
+        'CPUs      :cpunumber',
+        'CPU Speed :cpuspeed',
+        'Created   :created'
+      ]
+
+      params = { 'command' => "listServiceOfferings" }
+      params['filter']  = locate_config_value(:filter)  if locate_config_value(:filter)
+      params['keyword'] = locate_config_value(:keyword) if locate_config_value(:keyword)
+      params['name']    = locate_config_value(:name)    if locate_config_value(:name)
+      
+      result = connection.list_object(params, "serviceoffering")
+
+      result.each do |r|
+        r['memory'] = human_memory(r['memory']) if r['memory']
       end
 
-      columns = object_list.count
-      object_list = [] if locate_config_value(:noheader)
-
-      connection_result = connection.list_object(
-        "listServiceOfferings",
-        "serviceoffering",
-        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['memory'] ? human_memory(r['memory']) : 'Unknown')
-          object_list << r['cpunumber'].to_s
-          object_list << r['cpuspeed'].to_s + ' Mhz'
-          object_list << r['created']
-        end
-      end
-      puts ui.list(object_list, :uneven_columns_across, columns)
-      list_object_fields(connection_result) if locate_config_value(:fieldlist)
+      list_object(columns, result)
     end
 
     def human_memory n

data/lib/chef/knife/cs_stack_create.rb

@@ -102,10 +102,12 @@ module KnifeCloudstack
       cmd.config[:ssh_password] = config[:ssh_password]
       cmd.config[:ssh_port] = config[:ssh_port] || "22" # Chef::Config[:knife][:ssh_port]
       cmd.config[:identity_file] = config[:identity_file]
+      cmd.config[:keypair] = server[:keypair]
       cmd.config[:cloudstack_template] = server[:template] if server[:template]
       cmd.config[:cloudstack_service] = server[:service] if server[:service]
       cmd.config[:cloudstack_zone] = server[:zone] if server[:zone]
       server.has_key?(:public_ip) ? cmd.config[:public_ip] = server[:public_ip] : cmd.config[:no_public_ip] = true
+      cmd.config[:ik_private_ip] = server[:private_ip] if server[:private_ip]
       cmd.config[:bootstrap] = server[:bootstrap] if server.has_key?(:bootstrap) 
       cmd.config[:bootstrap_protocol] = server[:bootstrap_protocol] || "ssh"  
       cmd.config[:distro] = server[:distro] || "chef-full"  

data/lib/chef/knife/cs_template_list.rb

@@ -18,21 +18,14 @@
 # limitations under the License.
 #
 
-require 'chef/knife/cs_base'
+require 'chef/knife'
 require 'chef/knife/cs_baselist'
 
 module KnifeCloudstack
   class CsTemplateList < Chef::Knife
 
-    include Chef::Knife::KnifeCloudstackBase
     include Chef::Knife::KnifeCloudstackBaseList
 
-    deps do
-      require 'knife-cloudstack/connection'
-      require 'chef/knife'
-      Chef::Knife.load_deps
-    end
-
     banner "knife cs template list (options)"
 
     option :listall,
@@ -47,61 +40,39 @@ module KnifeCloudstack
 
     option :templatefilter,
            :long => "--templatefilter FILTER",
-           :description => "Default: 'featured'. Options: 'self','self-executable','executable','community'",
+           :description => "Default: 'featured'. Options: 'self','selfexecutable','sharedexecutable','executable','community'",
            :default => "featured"
 
     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) }
+      columns = [
+        'Name    :name',
+        'Size    :size',
+        'Zone    :zonename',
+        'Public  :ispublic',
+        'Created :created'
+      ]
+
+      params = { 'command' => "listTemplates" }
+      params['filter']  = locate_config_value(:filter)  if locate_config_value(:filter)
+      params['listall'] = locate_config_value(:listall) if locate_config_value(:listall)
+      params['keyword'] = locate_config_value(:keyword) if locate_config_value(:keyword)
+      params['name']    = locate_config_value(:name)    if locate_config_value(:name)
+
+      if ['all','featured','self','selfexecutable','sharedexecutable','executable','community'].include?(locate_config_value(:templatefilter)) 
+        params['templatefilter'] = locate_config_value(:templatefilter)
       else
-       [ 
-          ui.color('Name', :bold),
-          ui.color('Size', :bold),
-          ui.color('Zone', :bold),
-          ui.color('Public', :bold),
-          ui.color('Created', :bold)
-        ].each { |field| object_list << field }
-      end
+        params['templatefilter'] = 'featured'
+      end 
+
+      result = connection.list_object(params, "template")
 
-      columns = object_list.count
-      object_list = [] if locate_config_value(:noheader)
-
-      connection_result = connection.list_object(
-        "listTemplates",
-        "template",
-        locate_config_value(:filter),
-        locate_config_value(:listall),
-        nil,
-        nil,
-        params = { 'templatefilter' => locate_config_value(:templatefilter) }
-      )
-
-      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['size'] ? human_file_size(r['size']) : 'Unknown')
-          object_list << r['zonename'].to_s
-          object_list << r['ispublic'].to_s
-          object_list << r['created']
-        end
+      result.each do |r|
+        r['size'] = human_file_size(r['size']) if r['size']
       end
-      puts ui.list(object_list, :uneven_columns_across, columns)
-      list_object_fields(connection_result) if locate_config_value(:fieldlist)
+
+      list_object(columns, result)
     end
 
     def human_file_size n

data/lib/chef/knife/cs_template_register.rb

@@ -67,9 +67,9 @@ module KnifeCloudstack
 	   :description => "32 or 64 bits support, defaults to 64",
 	   :default => 64
 
-    option :extractable,
-           :long => "--[no-]extractable",
-	   :description => "Is the template extracable. Default: NO",
+    option :isextractable,
+           :long => "--[no-]isextractable",
+	   :description => "Is the template extractable. Default: NO",
 	   :boolean => true,
 	   :default => false
 
@@ -159,7 +159,7 @@ module KnifeCloudstack
         'zoneid' => zoneid,
         'bits' => locate_config_value(:bits),
       }
-      params['extracable'] = locate_config_value(:extractable) if locate_config_value(:extractable)
+      params['isextractable'] = locate_config_value(:isextractable) if locate_config_value(:isextractable)
       params['ispublic'] = locate_config_value(:public) if locate_config_value(:public)
       params['isfeatured'] = locate_config_value(:featured) if locate_config_value(:featured)
       params['passwordenabled'] = locate_config_value(:passwordenabled) if locate_config_value(:passwordenabled)

data/lib/chef/knife/cs_user_list.rb

@@ -16,20 +16,14 @@
 # limitations under the License.
 #
 
-require 'chef/knife/cs_base'
+require 'chef/knife'
 require 'chef/knife/cs_baselist'
       
 module KnifeCloudstack
   class CsUserList < Chef::Knife
 
-    include Chef::Knife::KnifeCloudstackBase
     include Chef::Knife::KnifeCloudstackBaseList
 
-    deps do
-      require 'knife-cloudstack/connection'
-      Chef::Knife.load_deps
-    end
-
     banner "knife cs user list (options)"
 
     option :listall,
@@ -44,49 +38,24 @@ module KnifeCloudstack
     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('Account', :bold),
-          ui.color('Type', :bold),
-          ui.color('State', :bold),
-          ui.color('Domain', :bold),
-          ui.color('Username', :bold),
-          ui.color('First', :bold),
-          ui.color('Last', :bold)
-        ]
-      end
-
-      columns = object_list.count
-      object_list = [] if locate_config_value(:noheader)
-
-      connection_result = connection.list_object(
-        "listUsers",
-        "user",
-        locate_config_value(:filter),
-        locate_config_value(:listall),
-        locate_config_value(:keyword)
-      )
-
-      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['account'].to_s 
-          object_list << r['accounttype'].to_s
-          object_list << r['state'].to_s
-          object_list << r['domain'].to_s
-          object_list << r['username'].to_s
-          object_list << r['firstname'].to_s
-          object_list << r['lastname'].to_s
-        end
-      end
-      puts ui.list(object_list, :uneven_columns_across, columns)
-      list_object_fields(connection_result) if locate_config_value(:fieldlist)
+      columns = [
+        'Account  :account',
+        'Type     :accounttype',
+        'State    :state',
+        'Domain   :domain',
+        'Username :username',
+        'First    :firstname',
+        'Last     :lastname'
+      ]
+
+      params = { 'command' => "listUsers" }
+      params['filter']  = locate_config_value(:filter)  if locate_config_value(:filter)
+      params['listall'] = locate_config_value(:listall) if locate_config_value(:listall)
+      params['keyword'] = locate_config_value(:keyword) if locate_config_value(:keyword)
+      params['name']    = locate_config_value(:name)    if locate_config_value(:name)
+      
+      result = connection.list_object(params, "user")
+      list_object(columns, result)
     end
 
   end