knife-cloudstack-fog 0.2.2

data/lib/chef/knife/cloudstack_instance_create.rb

@@ -0,0 +1,275 @@
+# Author:: Jeff Moody (<jmoody@datapipe.com>)
+# Copyright:: Copyright (c) 2012 Datapipe
+# 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/bootstrap'
+Chef::Knife::Bootstrap.load_deps
+require 'socket'
+require 'net/ssh/multi'
+require 'chef/json_compat'
+require 'chef/knife/cloudstack_base'
+
+class Chef
+  class Knife
+    class CloudstackServerCreate < Knife
+      
+      include Knife::CloudstackBase
+      
+      banner "knife cloudstack server create (options)"
+      
+      option  :cloudstack_serviceid,
+              :short => "-s SERVICEID",
+              :long => "--serviceid SERVICEID",
+              :description => "The CloudStack service offering ID."
+
+      option  :cloudstack_templateid,
+              :short => "-t TEMPLATEID",
+              :long => "--templateid TEMPLATEID",
+              :description => "The CloudStack template ID for the server."
+
+      option  :cloudstack_zoneid,
+              :short => "-z ZONEID",
+              :long => "--zoneid ZONE",
+              :description => "The CloudStack zone ID for the server."
+
+      option  :cloudstack_networknames,
+              :short => "-W NETWORKNAMES",
+              :long => "--networknames NETWORKNAMES",
+              :description => "Comma separated list of CloudStack network names. Each group name must be encapuslated in quotes if it contains whitespace.",
+              :proc => lambda { |n| n.split(/[\s,]+/) },
+              :default => []
+
+      option  :cloudstack_networkids,
+              :short => "-w NETWORKIDS",
+              :long => "--networkids NETWORKIDS",
+              :description => "Comma separated list of CloudStack network IDs.",
+              :proc => lambda { |n| n.split(/[\s,]+/) },
+              :default => []
+
+      option  :cloudstack_groupids,
+              :short => "-g SECURITYGROUPIDS",
+              :long => "--groupids SECURITYGROUPIDS",
+              :description => "Comma separated list of CloudStack Security Group IDs.",
+              :proc => lambda { |n| n.split(/[\s,]+/) },
+              :default => []
+
+      option  :cloudstack_groupnames,
+              :short => "-G SECURITYGROUPNAMES",
+              :long => "--groupnames SECURITYGROUPNAMES",
+              :description => "Comma separated list of CloudStack Security Group names. Each group name must be encapuslated in quotes if it contains whitespace.",
+              :proc => lambda { |n| n.split(/[\s,]+/) },
+              :default => []
+
+      option  :distro,
+              :short => "-d DISTRO",
+              :long => "--distro DISTRO",
+              :description => "Bootstrap a distro using a template; default is 'ubuntu10.04-gems'",
+              :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
+              :default => "ubuntu10.04-gems"
+
+      option  :template_file,
+              :long => "--template-file TEMPLATE",
+              :description => "Full path to location of template to use",
+              :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+              :default => false
+
+      option  :run_list,
+              :short => "-r RUN_LIST",
+              :long => "--run-list RUN_LIST",
+              :description => "Comma separated list of roles/recipes to apply",
+              :proc => lambda { |o| o.split(/[\s,]+/) },
+              :default => []
+
+      option  :ssh_user,
+              :short => "-x USERNAME",
+              :long => "--ssh-user USERNAME",
+              :description => "The ssh username",
+              :default => 'root'
+
+      option  :ssh_password,
+              :short => "-P PASSWORD",
+              :long => "--ssh-password PASSWORD",
+              :description => "The ssh password"
+              
+      option  :server_name,
+              :short => "-N NAME",
+              :long => "--server-name NAME",
+              :description => "The server name"
+      
+      option  :keypair,
+              :short => "-k KEYPAIR",
+              :long => "--keypair KEYPAIR",
+              :description => "The CloudStack Key Pair to use for password generation/storage"
+              
+      option  :diskoffering,
+              :short => "-D DISKOFFERINGID",
+              :long => "--diskoffering DISKOFFERINGID",
+              :description => "Specifies either the Disk Offering ID for the ROOT disk for an ISO template, or a DATA disk."
+        
+      def bootstrap_for_node(host, user, password)
+        Chef::Log.debug("Bootstrap host: #{host}")
+        Chef::Log.debug("Bootstrap user: #{user}")
+        Chef::Log.debug("Bootstrap pass: #{password}")
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = host
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:ssh_user] = user
+        bootstrap.config[:ssh_password] = password
+        bootstrap.config[:identity_file] = config[:identity_file]
+        bootstrap.config[:chef_node_name] = config[:server_name] if config[:server_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 tcp_test_ssh(hostname)
+        tcp_socket = TCPSocket.new(hostname, 22)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("\nsshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}\n")
+          yield
+          true
+        else
+          false
+        end
+        
+        rescue Errno::ETIMEDOUT
+          false
+        rescue Errno::EPERM
+          false
+        rescue Errno::ECONNREFUSED
+          sleep 2
+          false
+        rescue Errno::EHOSTUNREACH
+          sleep 2
+          false
+        ensure
+        tcp_socket && tcp_socket.close
+      end
+
+      def run
+        $stdout.sync = true
+        
+        options = {}
+
+        options['zoneid'] = locate_config_value(:cloudstack_zoneid)
+        options['templateid'] = locate_config_value(:cloudstack_templateid)
+
+        if locate_config_value(:cloudstack_serviceid) != nil
+          options['serviceofferingid'] = locate_config_value(:cloudstack_serviceid)
+        end
+        
+        if locate_config_value(:server_name) != nil
+          options['displayname'] = locate_config_value(:server_name)
+        end
+        
+        security_groups = []
+        if locate_config_value(:cloudstack_groupids) != []
+          cs_groupids = locate_config_value(:cloudstack_groupids)
+          cs_groupids.each do |id|
+            security_groups.push(id)
+          end
+          options['securitygroupids'] = security_groups
+        else
+          cs_groupnames = locate_config_value(:cloudstack_groupnames)
+          cs_groupnames.each do |name|
+            security_groups.push(name)
+          end
+          options['securitygroupnames'] = security_groups
+        end
+        
+        if locate_config_value(:keypair) != nil
+          options['keypair'] = locate_config_value(:keypair)
+        end
+        
+        if locate_config_value(:diskoffering) != nil
+          options['diskofferingid'] = locate_config_value(:diskoffering)
+        end
+        
+        Chef::Log.debug("Options: #{options} \n")
+
+        server = connection.deploy_virtual_machine(options)
+        jobid = server['deployvirtualmachineresponse'].fetch('jobid')
+
+        server_start = connection.query_async_job_result('jobid'=>jobid)
+        print "#{ui.color("Waiting for server", :magenta)}"
+        while server_start['queryasyncjobresultresponse'].fetch('jobstatus') != 1
+          print "#{ui.color(".", :magenta)}"
+          sleep(1)
+          server_start = connection.query_async_job_result('jobid'=>jobid)
+        end
+        puts "\n\n"
+
+        Chef::Log.debug("Job ID: #{jobid} \n")
+        Chef::Log.debug("Options: #{options} \n")
+        server_start = connection.query_async_job_result('jobid'=>jobid)
+        Chef::Log.debug("Server_Start: #{server_start} \n")
+        
+        server_info = server_start['queryasyncjobresultresponse']['jobresult']['virtualmachine']
+        
+        server_name = server_info['displayname']
+        server_id = server_info['hostname']
+        server_serviceoffering = server_info['serviceofferingname']
+        server_template = server_info['templatename']
+        if server_info['password'] != nil
+          ssh_password = server_info['password']
+        else
+          ssh_password = locate_config_value(:ssh_password)
+        end
+        
+        ssh_user = locate_config_value(:ssh_user)
+        
+        public_ip = nil
+        
+        if server_info['nic'].size > 0
+          public_ip = server_info['nic'].first['ipaddress']
+        end
+        
+        puts "\n\n"
+        puts "#{ui.color("Name", :cyan)}: #{server_name}"
+        puts "#{ui.color("Public IP", :cyan)}: #{public_ip}"
+        puts "#{ui.color("Username", :cyan)}: #{ssh_user}"
+        puts "#{ui.color("Password", :cyan)}: #{ssh_password}"
+        
+        print "\n#{ui.color("Waiting for sshd", :magenta)}"
+        
+        print("#{ui.color(".", :magenta)}") until tcp_test_ssh(public_ip) { sleep @initial_sleep_delay ||= 10; puts("done") }
+        
+        bootstrap_for_node(public_ip, ssh_user, ssh_password).run
+        
+        puts "\n"
+        puts "#{ui.color("Instance Name", :green)}: #{server_name}"
+        puts "#{ui.color("Instance ID", :green)}: #{server_id}"
+        puts "#{ui.color("Service Offering", :green)}: #{server_serviceoffering}"
+        puts "#{ui.color("Template", :green)}: #{server_template}"
+        puts "#{ui.color("Public IP Address", :green)}: #{public_ip}"
+        puts "#{ui.color("User", :green)}: #{ssh_user}"
+        puts "#{ui.color("Password", :green)}: #{ssh_password}"
+        puts "#{ui.color("Environment", :green)}: #{config[:environment] || '_default'}"
+        puts "#{ui.color("Run List", :green)}: #{config[:run_list].join(', ')}" 
+ 
+ 
+      end
+      
+    end
+  end
+end

data/lib/chef/knife/cloudstack_instance_delete.rb

@@ -0,0 +1,53 @@
+# Author:: Jeff Moody (<jmoody@datapipe.com>)
+# Copyright:: Copyright (c) 2012 Datapipe
+# 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/cloudstack_base'
+
+class Chef
+  class Knife
+    class CloudstackServerDelete < Knife
+
+      include Knife::CloudstackBase
+      banner "knife cloudstack server delete INSTANCE_ID [INSTANCE_ID] (options)"
+      
+      def run
+        
+        if @name_args.nil?
+          puts #{ui.color("Please provide an Instance ID.", :red)}
+        end
+
+        @name_args.each do |instance_id|
+          response = connection.list_virtual_machines('name' => instance_id)
+          instance_name = response['listvirtualmachinesresponse']['virtualmachine'].first['name']
+          instance_ip = response['listvirtualmachinesresponse']['virtualmachine'].first['nic'].first['ipaddress']
+          real_instance_id = response['listvirtualmachinesresponse']['virtualmachine'].first['id']
+          puts "#{ui.color("Name", :red)}: #{instance_name}"
+          puts "#{ui.color("Public IP", :red)}: #{instance_ip}"
+          puts "\n"
+          confirm("#{ui.color("Do you really want to delete this server", :red)}")
+          connection.destroy_virtual_machine('id' => real_instance_id)
+          ui.warn("Deleted server #{instance_name}")
+        end
+      end
+              
+
+      
+      
+    end
+  end
+end

data/lib/chef/knife/cloudstack_instance_list.rb

@@ -0,0 +1,91 @@
+# Author:: Chirag Jog (<chirag@clogeny.com>)
+# Copyright:: Copyright (c) 2011 Clogeny Technologies.
+# License:: Apache License, Version 2.0
+#
+# Author:: Jeff Moody (<jmoody@datapipe.com>)
+# Copyright:: Copyright (c) 2012 Datapipe
+# License:: Apache License, Version 2.0
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, 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/cloudstack_base'
+
+class Chef
+  class Knife
+    class CloudstackServerList < Knife
+
+      include Knife::CloudstackBase
+
+      banner "knife cloudstack server list (options)"
+
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        instance_list = [
+          ui.color('Instance ID', :bold),
+          ui.color('Display Name', :bold),
+          ui.color('IP Address', :bold),
+          ui.color('Security Group', :bold),
+          ui.color('Instance Zone', :bold),
+          ui.color('Service Offering', :bold),
+          ui.color('Template', :bold),
+          ui.color('State', :bold)
+        ]
+        
+        response = connection.list_virtual_machines['listvirtualmachinesresponse']
+        if virtual_machines = response['virtualmachine']
+          virtual_machines.each do |instance|
+              instance_list << instance['name'].to_s
+              instance_list << instance['displayname'].to_s
+              ip_list = []
+              instance['nic'].each do |nic|
+                ip_list << nic['ipaddress'].to_s
+              end
+              instance_list << ip_list.join(", ")
+              sg_list = []
+              instance['securitygroup'].each do |group|
+                sg_list << group['name'].to_s
+              end
+              instance_list << sg_list.join(", ")
+              
+              instance_list << instance['zonename'].to_s
+              instance_list << instance['serviceofferingname'].to_s
+              instance_list << instance['templatedisplaytext'].to_s
+              
+              instance_list << begin
+                state = instance['state'].to_s.downcase
+                case state
+                  when 'shutting-down','terminated','stopping','stopped'
+                    ui.color(state, :red)
+                  when 'pending', 'starting'
+                    ui.color(state, :yellow)
+                  else
+                    ui.color(state, :green)
+                end
+              end
+              
+          end
+          
+          puts ui.list(instance_list, :columns_across, 8)
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/cloudstack_keypair_list.rb

@@ -0,0 +1,53 @@
+# Author:: Jeff Moody (<jmoody@datapipe.com>)
+# Copyright:: Copyright (c) 2012 Datapipe
+# 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/cloudstack_base'
+
+class Chef
+  class Knife
+    class CloudstackKeypairList < Knife
+
+      include Knife::CloudstackBase
+
+      banner "knife cloudstack keypair list (options)"
+            
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        sshkeypair_list = [
+          ui.color('Name', :bold),
+          ui.color('Fingerprint', :bold),
+          ui.color('Private Key', :bold)
+        ]
+        response = connection.list_ssh_key_pairs['listsshkeypairsresponse']
+          if sshkeypairs = response['sshkeypair']
+            sshkeypairs.each do |sshkeypair|
+              sshkeypair_list << sshkeypair['name'].to_s
+              sshkeypair_list << sshkeypair['fingerprint'].to_s
+              sshkeypair_list << sshkeypair['privatekey'].to_s
+            end
+          end
+        puts ui.list(sshkeypair_list, :columns_across, 3)
+
+      end
+        
+    end
+  end
+end

data/lib/chef/knife/cloudstack_networks_list.rb

@@ -0,0 +1,67 @@
+# Author:: Jeff Moody (<jmoody@datapipe.com>)
+# Copyright:: Copyright (c) 2012 Datapipe
+# 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/cloudstack_base'
+
+class Chef
+  class Knife
+    class CloudstackNetworksList < Knife
+
+      include Knife::CloudstackBase
+
+      banner "knife cloudstack networks list (options)"
+            
+      def run
+        $stdout.sync = true
+
+        validate!
+
+        network_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Zone ID', :bold),
+          ui.color('VLAN', :bold),
+          ui.color('State', :bold)
+        ]
+        response = connection.list_networks['listnetworksresponse']
+          if networks = response['network']
+            networks.each do |network|
+              network_list << network['id'].to_s
+              network_list << network['name'].to_s
+              network_list << network['zoneid'].to_s
+              network_list << network['vlan'].to_s
+              network_list << begin
+                state = network['state'].to_s.downcase
+                case state
+                  when 'allocated'
+                    ui.color(state, :red)
+                  when 'pending'
+                    ui.color(state, :yellow)
+                  else
+                    ui.color(state, :green)
+                end
+              end
+            end
+          end
+        puts ui.list(network_list, :columns_across, 5)
+
+      end
+        
+    end
+  end
+end

data/lib/chef/knife/cloudstack_securitygroup_list.rb

@@ -0,0 +1,124 @@
+# Author:: Jeff Moody (<jmoody@datapipe.com>)
+# Copyright:: Copyright (c) 2012 Datapipe
+# 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/cloudstack_base'
+
+class Chef
+  class Knife
+    class CloudstackSecuritygroupList < Knife
+
+      include Knife::CloudstackBase
+
+      banner "knife cloudstack securitygroup list (options)"
+      option :groupid,
+             :short => "-g GROUPID",
+             :long => "--groupid GROUPID",
+             :description => "List the rules contained within a Security Group, specified by ID",
+             :default => 'none'
+      option :groupname,
+             :short => "-G GROUPNAME",
+             :long => "--groupname GROUPNAME",
+             :description => "List the rules contained within a Security Group, specified by name.",
+             :default => 'none'
+
+      def sg_details_list(securitygroup_list, securitygroup_details, groups, options={})
+        temp = groups
+        if groupid = options[:groupid]
+          temp.reject!{|g| g['id'] != groupid.to_i}
+        end
+        if groupname = options[:groupname]
+          temp.reject!{|g| g['name'] != groupname}
+        end
+        
+        temp.each do |securitygroup|
+          securitygroup_list << securitygroup['id'].to_s
+          securitygroup_list << securitygroup['name'].to_s
+          securitygroup_list << securitygroup['description'].to_s
+          if securitygroup['ingressrule'].nil?
+            securitygroup_details << ' '
+          else
+            securitygroup['ingressrule'].each do |ingressrule|
+              rule_details = []
+              securitygroup_details << ingressrule['protocol'].to_s
+              securitygroup_details << ingressrule['startport'].to_s
+              securitygroup_details << ingressrule['endport'].to_s
+              if ingressrule['cidr'].nil?
+                rule_details << ingressrule['securitygroupname'].to_s
+                rule_details << ingressrule['account'].to_s
+              else
+                rule_details << ingressrule['cidr'].to_s
+              end
+              securitygroup_details << rule_details.join(", ")
+            end
+          end
+        end
+      end
+            
+      def run
+        $stdout.sync = true
+
+        validate!
+        groupid = locate_config_value(:groupid)
+        groupname = locate_config_value(:groupname)
+
+        if (groupid == 'none' and groupname == 'none')
+          securitygroup_list = [
+            ui.color('ID', :bold),
+            ui.color('Name', :bold),
+            ui.color('Description', :bold)
+          ]
+          response = connection.list_security_groups['listsecuritygroupsresponse']
+            if securitygroups = response['securitygroup']
+              securitygroups.each do |securitygroup|
+                securitygroup_list << securitygroup['id'].to_s
+                securitygroup_list << securitygroup['name'].to_s
+                securitygroup_list << securitygroup['description'].to_s
+              end
+            end
+          puts ui.list(securitygroup_list, :columns_across, 3)
+        else
+          securitygroup_details = [
+            ui.color('Protocol', :bold),
+            ui.color('Start Port', :bold),
+            ui.color('End Port', :bold),
+            ui.color('Restricted To', :bold)
+          ]
+          securitygroup_list = [
+            ui.color('ID', :bold),
+            ui.color('Name', :bold),
+            ui.color('Description', :bold)
+            ]
+                        
+            if response = connection.list_security_groups['listsecuritygroupsresponse']
+              if securitygroups = response['securitygroup']
+                filters = {}
+                filters[:groupid] = groupid unless groupid == 'none'
+                filters[:groupname] = groupname unless groupname == 'none'
+                sg_details_list(securitygroup_list, securitygroup_details, securitygroups, filters)
+                
+                puts ui.list(securitygroup_list, :columns_across, 3)
+                puts ui.list(securitygroup_details, :columns_across, 4)
+              end
+            end
+            
+        end
+      end
+       
+    end
+  end
+end