knife-cloudstack 0.0.12 → 0.0.13

data/CHANGES.rdoc

@@ -1,4 +1,9 @@
 = Changes
+== 2012-11-29 (0.0.13)
+* Windows support
+  https://github.com/CloudStack-extras/knife-cloudstack/issues/31
+* Support for Projects
+* HTTPS support 
 
 == 2012-05-17 (0.0.12)
 * Adding option to disable public IP allocation on server create

data/README.rdoc

@@ -39,6 +39,8 @@ Additionally the following options may be set in your <tt>knife.rb</tt>:
 * knife[:distro]
 * knife[:template_file]
 
+== Public Clouds (Tata InstaCompute, Ninefold etc):
+To get this plugin to work in public clouds, it is essential that the virtual network (and router) be allocated to the account. Cloudstack clouds automatically creates a virtual network  when the first VM is requested to be created. Hence, it is essential to create the first VM (of a newly created account) manually(which can be terminated immediately if not required) to ensure the virtual network is created.
 
 == SUBCOMMANDS:
 
@@ -195,7 +197,7 @@ Reboots the specified virtual machines(s).
 == LICENSE:
 
 Author:: Ryan Holmes <rholmes@edmunds.com> 
-Author:: KC Braunschweig <kbraunschweig@edmunds.com>
+Author:: KC Braunschweig <kcbraunschweig@gmail.com>
 Author:: John E. Vincent <lusis.org+github.com@gmail.com>
 
 Copyright:: Copyright (c) 2011 Edmunds, Inc.

data/lib/chef/knife/cs_hosts.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Ryan Holmes (<rholmes@edmunds.com>)
-# Author:: KC Braunschweig (<kbraunschweig@edmunds.com>)
+# Author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
 # Copyright:: Copyright (c) 2011 Edmunds, Inc.
 # License:: Apache License, Version 2.0
 #

data/lib/chef/knife/cs_server_create.rb

@@ -18,18 +18,31 @@
 
 require 'chef/knife'
 require 'json'
+require 'chef/knife/winrm_base'
+require 'winrm'
+require 'httpclient'
+require 'em-winrm'
+
 
 module KnifeCloudstack
   class CsServerCreate < Chef::Knife
 
+    include Chef::Knife::WinrmBase
+
     # Seconds to delay between detecting ssh and initiating the bootstrap
-    BOOTSTRAP_DELAY = 3
+    BOOTSTRAP_DELAY = 20
+    #The machine will reboot once so we need to handle that
+    WINRM_BOOTSTRAP_DELAY = 200
 
     # Seconds to wait between ssh pings
-    SSH_POLL_INTERVAL = 2
+    SSH_POLL_INTERVAL = 10
 
     deps do
       require 'chef/knife/bootstrap'
+      require 'chef/knife/bootstrap_windows_winrm'
+      require 'chef/knife/bootstrap_windows_ssh'
+      require 'chef/knife/core/windows_bootstrap_context'
+      require 'chef/knife/winrm'
       Chef::Knife::Bootstrap.load_deps
       require 'socket'
       require 'net/ssh/multi'
@@ -86,6 +99,12 @@ module KnifeCloudstack
            :long => "--ssh-password PASSWORD",
            :description => "The ssh password"
 
+
+    option :ssh_port,
+           :long => "--ssh-port PORT",
+           :description => "The ssh port",
+           :default => "22"
+
     option :identity_file,
            :short => "-i IDENTITY_FILE",
            :long => "--identity-file IDENTITY_FILE",
@@ -157,10 +176,47 @@ module KnifeCloudstack
            :proc => lambda { |o| o.split(/[\s,]+/) },
            :default => []
 
+    option :cloudstack_project,
+           :short => "-P PROJECT_NAME",
+           :long => '--cloudstack-project PROJECT_NAME',
+           :description => "Cloudstack Project in which to create server",
+           :proc => Proc.new { |v| Chef::Config[:knife][:cloudstack_project] = v },
+           :default => nil
+
+    option :static_nat,
+            :long => '--static-nat',
+            :description => 'Support Static NAT',
+            :boolean => true,
+            :default => false
+
+    option :use_http_ssl,
+            :long => '--[no-]use-http-ssl',
+            :description => 'Support HTTPS',
+            :boolean => true,
+            :default => true
+            
+    option :bootstrap_protocol,
+      :long => "--bootstrap-protocol protocol",
+      :description => "Protocol to bootstrap windows servers. options: winrm/ssh",
+      :default => "ssh"
+
+    option :fqdn,
+      :long => '--fqdn',
+      :description => "FQDN which Kerberos Understands (only for Windows Servers)"
+
+
+    def connection
+      @connection ||= CloudstackClient::Connection.new(
+          locate_config_value(:cloudstack_url),
+          locate_config_value(:cloudstack_api_key),
+          locate_config_value(:cloudstack_secret_key),
+          locate_config_value(:cloudstack_project),
+          locate_config_value(:use_http_ssl)
+      )
+    end
 
     def run
-
-      # validate hostname and options
+      Chef::Log.debug("Validate hostname and options")
       hostname = @name_args.first
       unless /^[a-zA-Z0-9][a-zA-Z0-9-]*$/.match hostname then
         ui.error "Invalid hostname. Please specify a short hostname, not an fqdn (e.g. 'myhost' instead of 'myhost.domain.com')."
@@ -168,15 +224,26 @@ module KnifeCloudstack
       end
       validate_options
 
+      if @windows_image and locate_config_value(:kerberos_realm)
+        Chef::Log.debug("Load additional gems for AD/Kerberos Authentication")
+        if @windows_platform
+          require 'em-winrs'
+        else
+          require 'gssapi'
+        end
+      end
+
       $stdout.sync = true
 
-      connection = CloudstackClient::Connection.new(
-          locate_config_value(:cloudstack_url),
-          locate_config_value(:cloudstack_api_key),
-          locate_config_value(:cloudstack_secret_key)
-      )
+      Chef::Log.info("Creating instance with
+        service : #{locate_config_value(:cloudstack_service)}
+        template : #{locate_config_value(:cloudstack_template)}
+        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)}"
 
-      print "#{ui.color("Waiting for server", :magenta)}"
       server = connection.create_server(
           hostname,
           locate_config_value(:cloudstack_service),
@@ -188,82 +255,160 @@ module KnifeCloudstack
       public_ip = find_or_create_public_ip(server, connection)
 
       puts "\n\n"
-      puts "#{ui.color("Name", :cyan)}: #{server['name']}"
-      puts "#{ui.color("Public IP", :cyan)}: #{public_ip}"
+      puts "#{ui.color('Name', :cyan)}: #{server['name']}"
+      puts "#{ui.color('Public IP', :cyan)}: #{public_ip}"
 
       return if config[:no_bootstrap]
 
-      print "\n#{ui.color("Waiting for sshd", :magenta)}"
+      if @bootstrap_protocol == 'ssh'
+        print "\n#{ui.color("Waiting for sshd", :magenta)}"
 
-      print(".") until is_ssh_open?(public_ip) {
-        sleep BOOTSTRAP_DELAY
-        puts "\n"
-      }
-
-      bootstrap_for_node(public_ip).run
+        print(".") until is_ssh_open?(public_ip) {
+          sleep BOOTSTRAP_DELAY
+          puts "\n"
+        }
+      else
+        print "\n#{ui.color("Waiting for winrm to be active", :magenta)}"
+        print(".") until tcp_test_winrm(public_ip,locate_config_value(:winrm_port)) {
+          sleep WINRM_BOOTSTRAP_DELAY
+          puts("\n")
+        }
+      end
 
       puts "\n"
       puts "#{ui.color("Name", :cyan)}: #{server['name']}"
       puts "#{ui.color("Public IP", :cyan)}: #{public_ip}"
       puts "#{ui.color("Environment", :cyan)}: #{config[:environment] || '_default'}"
       puts "#{ui.color("Run List", :cyan)}: #{config[:run_list].join(', ')}"
+      bootstrap(server, public_ip).run
+    end
 
+    def fetch_server_fqdn(ip_addr)
+        require 'resolv'
+        Resolv.getname(ip_addr)
     end
 
-    def validate_options
+    def is_image_windows?
+        template = connection.get_template(locate_config_value(:cloudstack_template))
+        if !template
+          ui.error("Template: #{template} does not exist")
+          exit 1
+        end
+        return template['ostypename'].scan('Windows').length > 0
+    end
 
+    def validate_options
       unless locate_config_value :cloudstack_template
         ui.error "Cloudstack template not specified"
         exit 1
       end
+      @windows_image = is_image_windows?
+      @windows_platform = is_platform_windows?
 
       unless locate_config_value :cloudstack_service
         ui.error "Cloudstack service offering not specified"
         exit 1
       end
-
-      identity_file = locate_config_value :identity_file
-      ssh_user = locate_config_value :ssh_user
-      ssh_password = locate_config_value :ssh_password
-      unless identity_file || (ssh_user && ssh_password)
-        ui.error("You must specify either an ssh identity file or an ssh user and password")
-        exit 1
+      if locate_config_value(:bootstrap_protocol) == 'ssh'
+        identity_file = locate_config_value :identity_file
+        ssh_user = locate_config_value :ssh_user
+        ssh_password = locate_config_value :ssh_password
+        unless identity_file || (ssh_user && ssh_password)
+          ui.error("You must specify either an ssh identity file or an ssh user and password")
+          exit 1
+        end
+        @bootstrap_protocol = 'ssh'
+      elsif locate_config_value(:bootstrap_protocol) == 'winrm'
+        if not @windows_image
+          ui.error("Only Windows Images support WinRM protocol for bootstrapping.")
+          exit 1
+        end
+        winrm_user = locate_config_value :winrm_user
+        winrm_password = locate_config_value :winrm_password
+        winrm_transport = locate_config_value :winrm_transport
+        winrm_port = locate_config_value :winrm_port
+        unless winrm_user && winrm_password && winrm_transport && winrm_port
+          ui.error("WinRM User, Password, Transport and Port are compulsory parameters")
+          exit 1
+        end
+        @bootstrap_protocol = 'winrm'
       end
     end
 
-
     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['type'] != 'Virtual') then
+      if (config[:public_ip] == false)
         nic['ipaddress']
       else
-        # create ip address, ssh forwarding rule and optional forwarding rules
-        ip_address = connection.associate_ip_address(server['zoneid'])
-        ssh_rule = connection.create_port_forwarding_rule(ip_address['id'], "22", "TCP", "22", server['id'])
-        create_port_forwarding_rules(ip_address['id'], server['id'], connection)
-        ssh_rule['ipaddress']
+        puts("\nAllocate ip address, create forwarding rules")
+        ip_address = connection.associate_ip_address(server['zoneid'], locate_config_value(:cloudstack_networks))
+        #ip_address = connection.get_public_ip_address('202.2.94.158')
+        puts("\nAllocated IP Address: #{ip_address['ipaddress']}")
+        Chef::Log.debug("IP Address Info: #{ip_address}")
+
+        if locate_config_value :static_nat
+          Chef::Log.debug("Enabling static NAT for IP Address : #{ip_address['ipaddress']}")
+          connection.enable_static_nat(ip_address['id'], server['id'])
+        end
+        create_port_forwarding_rules(ip_address, server['id'], connection)
+        ip_address['ipaddress']
       end
     end
 
-    def create_port_forwarding_rules(ip_address_id, server_id, connection)
+    def create_port_forwarding_rules(ip_address, server_id, connection)
       rules = locate_config_value(:port_rules)
-      return unless rules
-
+      if @bootstrap_protocol == 'ssh'
+        rules += ["#{locate_config_value(:ssh_port)}"] #SSH Port
+      elsif @bootstrap_protocol == 'winrm'
+        rules +=[locate_config_value(:winrm_port)]
+      else
+        puts("\nUnsupported bootstrap protocol : #{@bootstrap_protocol}")
+        exit 1
+      end
+        return unless rules
       rules.each do |rule|
         args = rule.split(':')
         public_port = args[0]
         private_port = args[1] || args[0]
         protocol = args[2] || "TCP"
-        connection.create_port_forwarding_rule(ip_address_id, private_port, protocol, public_port, server_id)
+        if locate_config_value :static_nat
+          Chef::Log.debug("Creating IP Forwarding Rule for
+            #{ip_address['ipaddress']} with protocol: #{protocol}, public port: #{public_port}")
+          connection.create_ip_fwd_rule(ip_address['id'], protocol, public_port, public_port)
+        else
+          Chef::Log.debug("Creating Port Forwarding Rule for #{ip_address['id']} with protocol: #{protocol},
+            public port: #{public_port} and private port: #{private_port} and server: #{server_id}")
+          connection.create_port_forwarding_rule(ip_address['id'], private_port, protocol, public_port, server_id)
+        end
       end
+    end
 
+    def tcp_test_winrm(hostname, port)
+      TCPSocket.new(hostname, port)
+      return true
+      rescue SocketError
+        sleep 2
+        false
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        sleep 2
+        false
+      rescue Errno::EHOSTUNREACH
+        sleep 2
+        false
+      rescue Errno::ENETUNREACH
+        sleep 2
+        false
     end
 
     #noinspection RubyArgCount,RubyResolve
     def is_ssh_open?(ip)
       s = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      sa = Socket.sockaddr_in(22, ip)
+      sa = Socket.sockaddr_in(locate_config_value(:ssh_port), ip)
 
       begin
         s.connect_nonblock(sa)
@@ -288,31 +433,83 @@ module KnifeCloudstack
         s && s.close
       end
     end
+    def is_platform_windows?
+      return RUBY_PLATFORM.scan('w32').size > 0
+    end
 
+    def bootstrap(server, public_ip)
+      if @windows_image
+        Chef::Log.debug("Windows Bootstrapping")
+        bootstrap_for_windows_node(server, public_ip)
+      else
+        Chef::Log.debug("Linux Bootstrapping")
+        bootstrap_for_node(server, public_ip)
+      end
+    end
+    def bootstrap_for_windows_node(server, fqdn)
+        if locate_config_value(:bootstrap_protocol) == 'winrm'
+            bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
+            if locate_config_value(:kerberos_realm)
+              #Fetch AD/WINS based fqdn if any for Kerberos-based Auth
+              private_ip_address = connection.get_server_default_nic(server)["ipaddress"]
+              fqdn = locate_config_value(:fqdn) || fetch_server_fqdn(private_ip_address)
+            end
+            bootstrap.name_args = [fqdn]
+            bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
+            bootstrap.config[:winrm_password] = locate_config_value(:winrm_password)
+            bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
+            bootstrap.config[:winrm_port] = locate_config_value(:winrm_port)
+
+        elsif locate_config_value(:bootstrap_protocol) == 'ssh'
+            bootstrap = Chef::Knife::BootstrapWindowsSsh.new
+            bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
+            bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
+            bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
+            bootstrap.config[:identity_file] = locate_config_value(:identity_file)
+            bootstrap.config[:no_host_key_verify] = locate_config_value(:no_host_key_verify)
+        else
+            ui.error("Unsupported Bootstrapping Protocol. Supported : winrm, ssh")
+            exit 1
+        end
+        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]
+        bootstrap_common_params(bootstrap)
+    end
+    def bootstrap_common_params(bootstrap)
 
-    def bootstrap_for_node(host)
-      bootstrap = Chef::Knife::Bootstrap.new
-      bootstrap.name_args = [host]
       bootstrap.config[:run_list] = config[:run_list]
-      bootstrap.config[:ssh_user] = config[:ssh_user]
-      bootstrap.config[:ssh_password] = config[:ssh_password]
-      bootstrap.config[:identity_file] = config[:identity_file]
-      bootstrap.config[:chef_node_name] = config[:chef_node_name] if config[:chef_node_name]
       bootstrap.config[:prerelease] = config[:prerelease]
       bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
       bootstrap.config[:distro] = locate_config_value(:distro)
-      bootstrap.config[:use_sudo] = true
       bootstrap.config[:template_file] = locate_config_value(:template_file)
-      bootstrap.config[:environment] = config[:environment]
-      # may be needed for vpc_mode
-      bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
       bootstrap
     end
 
+
+    def bootstrap_for_node(server,fqdn)
+      bootstrap = Chef::Knife::Bootstrap.new
+      bootstrap.name_args = [fqdn]
+      # bootstrap.config[:run_list] = config[:run_list]
+      bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
+      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[:chef_node_name] = locate_config_value(:chef_node_name) || server.name
+      # bootstrap.config[:prerelease] = locate_config_value(:prerelease)
+      # bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+      # bootstrap.config[:distro] = locate_config_value(:distro)
+      bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
+      # bootstrap.config[:template_file] = config[:template_file]
+      bootstrap.config[:environment] = locate_config_value(:environment)
+      # may be needed for vpc_mode
+      bootstrap.config[:host_key_verify] = config[:host_key_verify]
+      bootstrap_common_params(bootstrap)
+    end
+
     def locate_config_value(key)
       key = key.to_sym
       Chef::Config[:knife][key] || config[key]
     end
-
-  end # class
+  end
 end

data/lib/chef/knife/cs_server_delete.rb

@@ -46,6 +46,19 @@ module KnifeCloudstack
            :description => "Your CloudStack secret key",
            :proc => Proc.new { |key| Chef::Config[:knife][:cloudstack_secret_key] = key }
 
+    option :cloudstack_project,
+           :short => "-P PROJECT_NAME",
+           :long => '--cloudstack-project PROJECT_NAME',
+           :description => "Cloudstack Project in which to create server",
+           :proc => Proc.new { |v| Chef::Config[:knife][:cloudstack_project] = v },
+           :default => nil
+
+    option :use_http_ssl,
+          :long => '--[no-]use-http-ssl',
+          :description => 'Support HTTPS',
+          :boolean => true,
+          :default => true
+
     def run
 
       @name_args.each do |hostname|
@@ -89,24 +102,15 @@ module KnifeCloudstack
     end
 
     def disassociate_virtual_ip_address(server)
-      nic = server['nic'].first || {}
-      return unless nic['type'] == 'Virtual'
-
-      # get the ssh rule for this server
-      ssh_rule = connection.get_ssh_port_forwarding_rule(server)
-      return unless ssh_rule
-
-      # get all rules for the same ip address
-      rules = connection.list_port_forwarding_rules(ssh_rule['ipaddressid'])
-      return unless rules
-
-      # ensure ip address has rules only for this server
-      rules.each { |r|
-        return if r['virtualmachineid'] != server['id']
-      }
-
-      # dissassociate the ip address if all tests passed
-      connection.disassociate_ip_address(ssh_rule['ipaddressid'])
+      ip_addr = connection.get_server_public_ip(server)
+      return unless ip_addr
+      ip_addr_info = connection.get_public_ip_address(ip_addr)
+      #Check if Public IP has been allocated and is not Source NAT
+      if ip_addr_info
+        if not ip_addr_info['issourcenat']
+          connection.disassociate_ip_address(ip_addr_info['id'])
+        end
+      end
     end
 
     def delete_client(name)
@@ -136,7 +140,9 @@ module KnifeCloudstack
         @connection = CloudstackClient::Connection.new(
             locate_config_value(:cloudstack_url),
             locate_config_value(:cloudstack_api_key),
-            locate_config_value(:cloudstack_secret_key)
+            locate_config_value(:cloudstack_secret_key),
+            locate_config_value(:cloudstack_project),
+            locate_config_value(:use_http_ssl)
         )
       end
       @connection

data/lib/chef/knife/cs_server_list.rb

@@ -45,6 +45,18 @@ module KnifeCloudstack
            :description => "Your CloudStack secret key",
            :proc => Proc.new { |key| Chef::Config[:knife][:cloudstack_secret_key] = key }
 
+    option :cloudstack_project,
+           :short => "-P PROJECT_NAME",
+           :long => '--cloudstack-project PROJECT_NAME',
+           :description => "Cloudstack Project in which to create server",
+           :proc => Proc.new { |v| Chef::Config[:knife][:cloudstack_project] = v },
+           :default => nil
+
+    option :use_http_ssl,
+          :long => '--[no-]use-http-ssl',
+          :description => 'Support HTTPS',
+          :boolean => true,
+          :default => true     
     def run
 
       $stdout.sync = true
@@ -52,7 +64,9 @@ module KnifeCloudstack
       connection = CloudstackClient::Connection.new(
           locate_config_value(:cloudstack_url),
           locate_config_value(:cloudstack_api_key),
-          locate_config_value(:cloudstack_secret_key)
+          locate_config_value(:cloudstack_secret_key),
+          locate_config_value(:cloudstack_project),
+          locate_config_value(:use_http_ssl)
       )
 
       server_list = [
@@ -60,7 +74,8 @@ module KnifeCloudstack
           ui.color('Public IP', :bold),
           ui.color('Service', :bold),
           ui.color('Template', :bold),
-          ui.color('State', :bold)
+          ui.color('State', :bold),
+          ui.color('Hypervisor', :bold)
       ]
 
       servers = connection.list_servers
@@ -78,8 +93,9 @@ module KnifeCloudstack
         server_list << server['serviceofferingname']
         server_list << server['templatename']
         server_list << server['state']
+        server_list << (server['hostname'] || 'N/A')
       end
-      puts ui.list(server_list, :columns_across, 5)
+      puts ui.list(server_list, :columns_across, 6)
 
     end
 

data/lib/chef/knife/cs_server_reboot.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Ryan Holmes (<rholmes@edmunds.com>)
-# Author:: KC Braunschweig (<kbraunschweig@edmunds.com>)
+# Author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
 # Copyright:: Copyright (c) 2011 Edmunds, Inc.
 # License:: Apache License, Version 2.0
 #

data/lib/chef/knife/cs_server_start.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Ryan Holmes (<rholmes@edmunds.com>)
-# Author:: KC Braunschweig (<kbraunschweig@edmunds.com>)
+# Author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
 # Copyright:: Copyright (c) 2011 Edmunds, Inc.
 # License:: Apache License, Version 2.0
 #

data/lib/chef/knife/cs_server_stop.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Ryan Holmes (<rholmes@edmunds.com>)
-# Author:: KC Braunschweig (<kbraunschweig@edmunds.com>)
+# Author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
 # Copyright:: Copyright (c) 2011 Edmunds, Inc.
 # License:: Apache License, Version 2.0
 #

data/lib/chef/knife/cs_stack_create.rb

@@ -171,7 +171,7 @@ module KnifeCloudstack
         query = "(#{query})" + " AND chef_environment:#{get_environment}"
       end
 
-      Chef::Log.debug("Searching for nodes: #{query}")
+      Chef::Chef::Log.debug("Searching for nodes: #{query}")
 
       q = Chef::Search::Query.new
       nodes = Array(q.search(:node, query))

data/lib/chef/knife/cs_template_list.rb

@@ -53,12 +53,27 @@ module KnifeCloudstack
            :description => "Your CloudStack secret key",
            :proc => Proc.new { |key| Chef::Config[:knife][:cloudstack_secret_key] = key }
 
+    option :cloudstack_project,
+           :short => "-P PROJECT_NAME",
+           :long => '--cloudstack-project PROJECT_NAME',
+           :description => "Cloudstack Project in which to create server",
+           :proc => Proc.new { |v| Chef::Config[:knife][:cloudstack_project] = v },
+           :default => nil
+
+    option :use_http_ssl,
+          :long => '--[no-]use-http-ssl',
+          :description => 'Support HTTPS',
+          :boolean => true,
+          :default => true       
+
     def run
 
       connection = CloudstackClient::Connection.new(
           locate_config_value(:cloudstack_url),
           locate_config_value(:cloudstack_api_key),
-          locate_config_value(:cloudstack_secret_key)
+          locate_config_value(:cloudstack_secret_key),
+          locate_config_value(:cloudstack_project),
+          locate_config_value(:use_http_ssl)
       )
 
       template_list = [
@@ -73,7 +88,7 @@ module KnifeCloudstack
       templates = connection.list_templates(filter)
       templates.each do |t|
         template_list << t['name']
-        template_list << (human_file_size(t['size']) || 'Unknown')
+        #template_list << (human_file_size(t['size']) || 'Unknown')
         template_list << t['zonename']
         template_list << t['ispublic'].to_s
         template_list << t['created']

data/lib/knife-cloudstack/connection.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Ryan Holmes (<rholmes@edmunds.com>)
-# Author:: KC Braunschweig (<kbraunschweig@edmunds.com>)
+# Author:: KC Braunschweig (<kcbraunschweig@gmail.com>)
 # Copyright:: Copyright (c) 2011 Edmunds, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -28,13 +28,24 @@ require 'json'
 module CloudstackClient
   class Connection
 
-    ASYNC_POLL_INTERVAL = 2.0
-    ASYNC_TIMEOUT = 300
+    ASYNC_POLL_INTERVAL = 5.0
+    ASYNC_TIMEOUT = 600
 
-    def initialize(api_url, api_key, secret_key)
+    def initialize(api_url, api_key, secret_key, project_name=nil, use_ssl=true)
       @api_url = api_url
       @api_key = api_key
       @secret_key = secret_key
+      @project_id = nil
+      @use_ssl = use_ssl
+      if project_name
+        project = get_project(project_name)
+        if !project then
+          puts "Project #{project_name} does not exist"
+          exit 1
+        end
+        @project_id = project['id']
+      end
+
     end
 
     ##
@@ -45,6 +56,9 @@ module CloudstackClient
           'command' => 'listVirtualMachines',
           'name' => name
       }
+      # if @project_id
+      #   params['projectId'] = @project_id
+      # end
       json = send_request(params)
       machines = json['virtualmachine']
 
@@ -60,15 +74,18 @@ module CloudstackClient
 
     def get_server_public_ip(server, cached_rules=nil)
       return nil unless server
-
       # find the public ip
-      nic = get_server_default_nic(server) || {}
-      if nic['type'] == 'Virtual' then
-        ssh_rule = get_ssh_port_forwarding_rule(server, cached_rules)
-        ssh_rule ? ssh_rule['ipaddress'] : nil
-      else
-        nic['ipaddress']
+      nic = get_server_default_nic(server)
+      ssh_rule = get_ssh_port_forwarding_rule(server, cached_rules)
+      if ssh_rule
+        return ssh_rule['ipaddress']
+      end
+      #check for static NAT
+      ip_addr = list_public_ip_addresses.find {|v| v['virtualmachineid'] == server['id']}
+      if ip_addr
+        return ip_addr['ipaddress']
       end
+      nic['ipaddress']
     end
 
     ##
@@ -102,6 +119,9 @@ module CloudstackClient
       params = {
           'command' => 'listVirtualMachines'
       }
+      # if @project_id
+      #   params['projectId'] = @project_id
+      # end
       json = send_request(params)
       json['virtualmachine'] || []
     end
@@ -147,7 +167,7 @@ module CloudstackClient
         networks << get_network(name)
       end
       if networks.empty? then
-        networks << get_default_network
+        networks << get_default_network(zone['id'])
       end
       if networks.empty? then
         puts "No default network found"
@@ -164,6 +184,10 @@ module CloudstackClient
           'zoneId' => zone['id'],
           'networkids' => network_ids.join(',')
       }
+      # if @project_id
+      #   params['projectId'] = @project_id
+      # end
+
       params['name'] = host_name if host_name
 
       json = send_async_request(params)
@@ -338,6 +362,25 @@ module CloudstackClient
       json['template'] || []
     end
 
+    #Fetch project with the specified name
+    def get_project(name)
+      params = {
+        'command' => 'listProjects'
+      }
+
+      json = send_request(params)
+      projects = json['project']
+      return nil unless projects
+      projects.each { |n|
+        if n['name'] == name then
+          return n
+        end
+      }
+
+      nil
+    end
+
+
     ##
     # Finds the network with the specified name.
 
@@ -345,6 +388,9 @@ module CloudstackClient
       params = {
           'command' => 'listNetworks'
       }
+      # if @project_id
+      #   params['projectId'] = @project_id
+      # end
       json = send_request(params)
 
       networks = json['network']
@@ -362,11 +408,15 @@ module CloudstackClient
     ##
     # Finds the default network.
 
-    def get_default_network
+    def get_default_network(zone)
       params = {
           'command' => 'listNetworks',
-          'isDefault' => true
+          'isDefault' => true,
+          'zoneid' => zone
       }
+      # if @project_id
+      #   params['projectId'] = @project_id
+      # end
       json = send_request(params)
 
       networks = json['network']
@@ -455,23 +505,66 @@ module CloudstackClient
           'ipaddress' => ip_address
       }
       json = send_request(params)
+      return nil unless json['publicipaddress']
       json['publicipaddress'].first
     end
 
+    def list_public_ip_addresses()
+      params = { 'command' => 'listPublicIpAddresses'}
 
+      json = send_request(params)
+      return json['publicipaddress']
+    end
     ##
     # Acquires and associates a public IP to an account.
 
-    def associate_ip_address(zone_id)
+    def associate_ip_address(zone_id, networks)
       params = {
           'command' => 'associateIpAddress',
           'zoneId' => zone_id
       }
-
+      #Choose the first network from the list
+      if networks.size > 0
+        params['networkId'] = get_network(networks.first)['id']
+      else
+        default_network = get_default_network(zone_id)
+        params['networkId'] = default_network['id']
+      end
+      print "params: #{params}"
       json = send_async_request(params)
       json['ipaddress']
     end
 
+    def enable_static_nat(ipaddress_id, virtualmachine_id)
+      params = {
+        'command' => 'enableStaticNat',
+        'ipAddressId' => ipaddress_id,
+        'virtualmachineId' => virtualmachine_id
+      }
+      send_request(params)
+    end
+
+    def disable_static_nat(ipaddress)
+      params = {
+        'command' => 'disableStaticNat',
+        'ipAddressId' => ipaddress['id']
+      }
+      send_async_request(params)
+    end
+
+    def create_ip_fwd_rule(ipaddress_id, protocol, start_port, end_port)
+      params = {
+        'command' => 'createIpForwardingRule',
+        'ipaddressId' => ipaddress_id,
+        'protocol' => protocol,
+        'startport' =>  start_port,
+        'endport' => end_port
+      }
+
+      send_async_request(params)
+    end
+
+
     ##
     # Disassociates an ip address from the account.
     #
@@ -529,10 +622,13 @@ module CloudstackClient
     ##
     # Sends a synchronous request to the CloudStack API and returns the response as a Hash.
     #
-    # The wrapper element of the response (e.g. mycommandresponse) is discarded and the 
+    # The wrapper element of the response (e.g. mycommandresponse) is discarded and the
     # contents of that element are returned.
 
     def send_request(params)
+      if @project_id
+        params['projectId'] = @project_id
+      end
       params['response'] = 'json'
       params['apiKey'] = @api_key
 
@@ -547,8 +643,12 @@ module CloudstackClient
       signature = CGI.escape(signature)
 
       url = "#{@api_url}?#{data}&signature=#{signature}"
-
-      response = Net::HTTP.get_response(URI.parse(url))
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = @use_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      request = Net::HTTP::Get.new(uri.request_uri)
+      response = http.request(request)
 
       if !response.is_a?(Net::HTTPOK) then
         puts "Error #{response.code}: #{response.message}"

metadata

@@ -1,103 +1,103 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: knife-cloudstack
-version: !ruby/object:Gem::Version 
-  hash: 7
+version: !ruby/object:Gem::Version
+  version: 0.0.13
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 12
-  version: 0.0.12
 platform: ruby
-authors: 
+authors:
 - Ryan Holmes
 - KC Braunschweig
 - John E. Vincent
+- Chirag Jog
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-05-17 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 55
-        segments: 
-        - 0
-        - 10
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: knife-windows
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A Knife plugin to create, list and manage CloudStack servers
-email: 
+email:
 - rholmes@edmunds.com
-- kbraunschweig@edmunds.com
+- kcbraunschweig@gmail.com
 - lusis.org+github.com@gmail.com
+- chirag.jog@me.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - CHANGES.rdoc
 - LICENSE
-files: 
+files:
 - CHANGES.rdoc
 - README.rdoc
 - LICENSE
 - lib/knife-cloudstack/connection.rb
-- lib/chef/knife/cs_stack_delete.rb
 - lib/chef/knife/cs_server_list.rb
 - lib/chef/knife/cs_network_list.rb
 - lib/chef/knife/cs_server_delete.rb
 - lib/chef/knife/cs_template_list.rb
-- lib/chef/knife/cs_server_reboot.rb
-- lib/chef/knife/cs_server_start.rb
-- lib/chef/knife/cs_service_list.rb
-- lib/chef/knife/cs_zone_list.rb
 - lib/chef/knife/cs_server_stop.rb
+- lib/chef/knife/cs_zone_list.rb
+- lib/chef/knife/cs_stack_delete.rb
 - lib/chef/knife/cs_hosts.rb
 - lib/chef/knife/cs_stack_create.rb
+- lib/chef/knife/cs_service_list.rb
+- lib/chef/knife/cs_server_start.rb
 - lib/chef/knife/cs_server_create.rb
+- lib/chef/knife/cs_server_reboot.rb
 homepage: http://cloudstack.org/
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A knife plugin for the CloudStack API
 test_files: []
-