knife-joyent 0.0.10 → 0.1.0

data/lib/chef/knife/joyent_server_create.rb

@@ -1,168 +1,255 @@
-require File.expand_path(File.dirname(__FILE__) + '/base')
+require 'chef/knife/joyent_base'
 
-module KnifeJoyent
-  class JoyentServerCreate < Chef::Knife
+class Chef
+  class Knife
+    class JoyentServerCreate < Knife
 
-    include KnifeJoyent::Base
+      include Knife::JoyentBase
 
-    deps do
-      require 'fog'
-      require 'readline'
-      require 'chef/json_compat'
-      require 'chef/knife/bootstrap'
-      Chef::Knife::Bootstrap.load_deps
-    end
-    
-    banner 'knife joyent server create (options)'
-
-    # mixlib option parsing
-    option :name,
-      :long => '--name <name>',
-      :description => 'name for this machine'
-
-    option :package,
-      :short => '-f FLAVOR_NAME',
-      :long => '--flavor FLAVOR_NAME',
-      :description => 'specify flavor/package for the server'
-
-    option :dataset,
-      :short => '-I IMAGE_ID',
-      :long => '--image IMAGE_ID',
-      :description => 'specify image for the server'
-
-    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 :identity_file,
-      :short => "-i IDENTITY_FILE",
-      :long => "--identity-file IDENTITY_FILE",
-      :description => "The SSH identity file used for authentication"
-
-    option :chef_node_name,
-      :short => "-N NAME",
-      :long => "--node-name NAME",
-      :description => "The Chef node name for your new node"
-
-    option :prerelease,
-      :long => "--prerelease",
-      :description => "Install the pre-release chef gems"
-
-    option :distro,
-      :short => "-d DISTRO",
-      :long => "--distro DISTRO",
-      :description => "Bootstrap a distro using a template",
-      :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
-      :default => "chef-full"
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        require 'ipaddr'
+        Chef::Knife::Bootstrap.load_deps
+      end
+
+      banner 'knife joyent server create (options)'
+
+
+      def is_linklocal(ip)
+        linklocal = IPAddr.new "169.254.0.0/16"
+        return linklocal.include?(ip)
+      end
+
+      def is_loopback(ip)
+        loopback = IPAddr.new "127.0.0.0/8"
+        return loopback.include?(ip)
+      end
+
+      def is_private(ip)
+        block_a = IPAddr.new "10.0.0.0/8"
+        block_b = IPAddr.new "172.16.0.0/12"
+        block_c = IPAddr.new "192.168.0.0/16"
+        return (block_a.include?(ip) or block_b.include?(ip) or block_c.include?(ip))
+      end
+
+      option :package,
+        :short => '-f FLAVOR_NAME',
+        :long => '--flavor FLAVOR_NAME',
+        :description => 'specify flavor/package for the server'
+
+      option :dataset,
+        :short => '-I IMAGE_ID',
+        :long => '--image IMAGE_ID',
+        :description => 'specify image for the server'
+
+      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 :private_network,
+        :long => "--private-network",
+        :description => "Use the private IP for bootstrapping rather than the public IP",
+        :boolean => true,
+        :default => false
+
+      option :ssh_user,
+        :short => "-x USERNAME",
+        :long => "--ssh-user USERNAME",
+        :description => "The ssh username",
+        :default => "root"
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      option :chef_node_name,
+        :short => "-N NAME",
+        :long => "--node-name NAME",
+        :description => "The Chef node name for your new node"
+
+      option :prerelease,
+        :long => "--prerelease",
+        :description => "Install the pre-release chef gems"
+
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template",
+        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
+        :default => "chef-full"
+
+      option :no_host_key_verify,
+        :long => "--no-host-key-verify",
+        :description => "Disable host key verification",
+        :boolean => true,
+        :default => false
+
+      def is_linklocal(ip)
+        linklocal = IPAddr.new "169.254.0.0/16"
+        return linklocal.include?(ip)
+      end
+      
+      def is_loopback(ip)
+        loopback = IPAddr.new "127.0.0.0/8"
+        return loopback.include?(ip)
+      end
       
-    option :no_host_key_verify,
-      :long => "--no-host-key-verify",
-      :description => "Disable host key verification",
-      :boolean => true,
-      :default => false
-
-    # wait for ssh to come up
-    def tcp_test_ssh(hostname)
-      tcp_socket = TCPSocket.new(hostname, 22)
-      readable = IO.select([tcp_socket], nil, nil, 5)
-      if readable
-        Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
-        yield
-        true
-      else
+      def is_private(ip)
+        block_a = IPAddr.new "10.0.0.0/8"
+        block_b = IPAddr.new "172.16.0.0/12"
+        block_c = IPAddr.new "192.168.0.0/16"
+        return (block_a.include?(ip) or block_b.include?(ip) or block_c.include?(ip))
+      end
+
+      # wait for ssh to come up
+      def tcp_test_ssh(hostname)
+        tcp_socket = TCPSocket.new(hostname, 22)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
+          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
-    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
 
+      # Run Chef bootstrap script
+      def bootstrap_for_node(server, bootstrap_ip_address)
+        bootstrap = Chef::Knife::Bootstrap.new
+        Chef::Log.debug("Bootstrap name_args = [ #{bootstrap_ip_address} ]")
+        bootstrap.name_args = [ bootstrap_ip_address ]
+        Chef::Log.debug("Bootstrap run_list = #{config[:run_list]}")
+        bootstrap.config[:run_list] = config[:run_list]
+        Chef::Log.debug("Bootstrap ssh_user = #{config[:ssh_user]}")
+        bootstrap.config[:ssh_user] = config[:ssh_user]
+        Chef::Log.debug("Bootstrap identity_file = #{config[:identity_file]}")
+        bootstrap.config[:identity_file] = config[:identity_file]
+        Chef::Log.debug("Bootstrap chef_node_name = #{config[:chef_node_name]}")
+        bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.id
+        Chef::Log.debug("Bootstrap prerelease = #{config[:prerelease]}")
+        bootstrap.config[:prerelease] = config[:prerelease]
+        Chef::Log.debug("Bootstrap distro = #{config[:distro]}")
+        bootstrap.config[:distro] = config[:distro]
+        #Chef::Log.debug("Bootstrap use_sudo = #{config[:use_sudo]}")
+        #bootstrap.config[:use_sudo] = true
+        Chef::Log.debug("Bootstrap environment = #{config[:environment]}")
+        bootstrap.config[:environment] = config[:environment]
+        Chef::Log.debug("Bootstrap no_host_key_verify = #{config[:no_host_key_verify]}")
+        bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
+
+        bootstrap
+      end
 
-    # Run Chef bootstrap script
-    def bootstrap_for_node(server)
-      bootstrap = Chef::Knife::Bootstrap.new
-      Chef::Log.debug("Bootstrap name_args = [ #{server.ips.first} ]")
-      bootstrap.name_args = [ server.ips.first ]
-      Chef::Log.debug("Bootstrap run_list = #{config[:run_list]}")
-      bootstrap.config[:run_list] = config[:run_list]
-      Chef::Log.debug("Bootstrap ssh_user = #{config[:ssh_user]}")
-      bootstrap.config[:ssh_user] = config[:ssh_user]
-      Chef::Log.debug("Bootstrap identity_file = #{config[:identity_file]}")
-      bootstrap.config[:identity_file] = config[:identity_file]
-      Chef::Log.debug("Bootstrap chef_node_name = #{config[:chef_node_name]}")
-      bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.id
-      Chef::Log.debug("Bootstrap prerelease = #{config[:prerelease]}")
-      bootstrap.config[:prerelease] = config[:prerelease]
-      Chef::Log.debug("Bootstrap distro = #{config[:distro]}")
-      bootstrap.config[:distro] = config[:distro]
-      #Chef::Log.debug("Bootstrap use_sudo = #{config[:use_sudo]}")
-      #bootstrap.config[:use_sudo] = true
-      Chef::Log.debug("Bootstrap environment = #{config[:environment]}")
-      bootstrap.config[:environment] = config[:environment]
-      Chef::Log.debug("Bootstrap no_host_key_verify = #{config[:no_host_key_verify]}")
-      bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
-
-      bootstrap
-    end
+      def run
+        $stdout.sync = true
 
-    # Go
-    def run
-      puts ui.color("Creating machine #{config[:chef_node_name]}", :cyan)
-      begin
-        server = self.connection.servers.create(:dataset => config[:dataset],
-                                            :package => config[:package],
-                                            :name => config[:name])
-      server.wait_for { print "."; ready? }                                      
-      rescue => e
-        Chef::Log.debug("e: #{e}")
-        if e.response && e.response.body.kind_of?(String)
-          error = MultiJson.decode(e.response.body)
-          puts ui.error(error['message'])
-          exit 1
+        # add some validation here ala knife-ec2
+
+        node_name = config[:chef_node_name] || config[:server_name]
+
+        puts ui.color("Creating machine #{node_name}", :cyan)
+
+        server = connection.servers.create(
+          :name => node_name,
+          :dataset => config[:dataset],
+          :package => config[:package]
+        )
+
+        print "\n#{ui.color("Waiting for server", :magenta)}"
+        server.wait_for { print "."; ready? }
+
+        #which IP address to bootstrap
+        bootstrap_ip_addresses = server.ips.select{|ip| 
+          ip and not(is_loopback(ip) or is_linklocal(ip))
+        }
+
+        if bootstrap_ip_addresses.count == 1
+          bootstrap_ip_address = bootstrap_ip_addresses.first
         else
-          raise
+          if config[:private_network]
+            bootstrap_ip_address = bootstrap_ip_addresses.find{|ip| is_private(ip)}
+          else
+            bootstrap_ip_address = bootstrap_ip_addresses.find{|ip| not is_private(ip)}
+          end
         end
+
+        Chef::Log.debug("Bootstrap IP Address #{bootstrap_ip_address}")
+        if bootstrap_ip_address.nil?
+          ui.error("No IP address available for bootstrapping.")
+          exit 1
+        end
+
+        puts ui.color("attempting to bootstrap on #{bootstrap_ip_address}", :cyan)
+
+        print(".") until tcp_test_ssh(bootstrap_ip_address) {
+          sleep @initial_sleep_delay ||= 10
+          puts("done")
+        }
+
+        bootstrap_for_node(server, bootstrap_ip_address).run
+
+        puts ui.color("Created machine:", :cyan)
+        msg_pair("ID", server.id.to_s)
+        msg_pair("Name", server.name)
+        msg_pair("State", server.state)
+        msg_pair("Type", server.type)
+        msg_pair("Dataset", server.dataset)
+        msg_pair("IP's", server.ips)
+      end
+
+      # Run Chef bootstrap script
+      def bootstrap_for_node(server, bootstrap_ip_address)
+        bootstrap = Chef::Knife::Bootstrap.new
+        Chef::Log.debug("Bootstrap name_args = [ #{bootstrap_ip_address} ]")
+        bootstrap.name_args = [ bootstrap_ip_address ]
+        Chef::Log.debug("Bootstrap run_list = #{config[:run_list]}")
+        bootstrap.config[:run_list] = config[:run_list]
+        Chef::Log.debug("Bootstrap ssh_user = #{config[:ssh_user]}")
+        bootstrap.config[:ssh_user] = config[:ssh_user]
+        Chef::Log.debug("Bootstrap identity_file = #{config[:identity_file]}")
+        bootstrap.config[:identity_file] = config[:identity_file]
+        Chef::Log.debug("Bootstrap chef_node_name = #{config[:chef_node_name]}")
+        bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.id
+        Chef::Log.debug("Bootstrap prerelease = #{config[:prerelease]}")
+        bootstrap.config[:prerelease] = config[:prerelease]
+        Chef::Log.debug("Bootstrap distro = #{config[:distro]}")
+        bootstrap.config[:distro] = config[:distro]
+        #Chef::Log.debug("Bootstrap use_sudo = #{config[:use_sudo]}")
+        #bootstrap.config[:use_sudo] = true
+        Chef::Log.debug("Bootstrap environment = #{config[:environment]}")
+        bootstrap.config[:environment] = config[:environment]
+        Chef::Log.debug("Bootstrap no_host_key_verify = #{config[:no_host_key_verify]}")
+        bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
+
+        bootstrap
       end
       
-      puts ui.color("Created machine:", :cyan)
-      msg("ID", server.id.to_s)
-      msg("Name", server.name)
-      msg("State", server.state)
-      msg("Type", server.type)
-      msg("Dataset", server.dataset)
-      msg("IP's", server.ips)
-      puts ui.color("attempting to bootstrap on #{server.ips.first}", :cyan)
-    
-      print(".") until tcp_test_ssh(server.ips.first) {
-        sleep 1
-        puts("done")
-      }
-      bootstrap_for_node(server).run
-      exit 0
-    end
-    
-    def msg(label, value = nil)
-      if value && !value.empty?
-        puts "#{ui.color(label, :cyan)}: #{value}"
+      def msg_pair(label, value = nil)
+        if value && !value.empty?
+          puts "#{ui.color(label, :cyan)}: #{value}"
+        end
       end
     end
   end
 end
+

data/lib/chef/knife/joyent_server_delete.rb

@@ -1,72 +1,74 @@
-require File.expand_path(File.dirname(__FILE__) + '/base')
+require 'chef/knife/joyent_base'
 
 require 'chef/api_client'
 
-module KnifeJoyent
-  class JoyentServerDelete < Chef::Knife
+class Chef
+  class Knife
+    class JoyentServerDelete < Knife
 
-    include KnifeJoyent::Base
+      include Knife::JoyentBase
 
-    banner 'knife joyent server delete <server_id>'
+      banner 'knife joyent server delete <server_id>'
 
-    def run
-      unless name_args.size === 1
-        show_usage
-        exit 1
-      end
+      def run
+        unless name_args.size === 1
+          show_usage
+          exit 1
+        end
 
-      id = name_args.first
+        id = name_args.first
 
-      server = self.connection.servers.get(id)
-      
-      msg("ID", server.id.to_s)
-      msg("Name", server.name)
-      msg("State", server.state)
-      msg("Type", server.type)
-      msg("Dataset", server.dataset)
-      msg("IP's", server.ips)
-     
-      unless server
-        puts ui.error("Unable to locate server: #{id}")
-        exit 1
-      end
-     
-      puts "\n"
-      confirm("Do you really want to delete this server")
-     
-      puts ui.color("Stopping server...", :cyan)
+        server = self.connection.servers.get(id)
+        
+        msg("ID", server.id.to_s)
+        msg("Name", server.name)
+        msg("State", server.state)
+        msg("Type", server.type)
+        msg("Dataset", server.dataset)
+        msg("IP's", server.ips)
+       
+        unless server
+          puts ui.error("Unable to locate server: #{id}")
+          exit 1
+        end
+       
+        puts "\n"
+        confirm("Do you really want to delete this server")
+       
+        puts ui.color("Stopping server...", :cyan)
 
-      if server.stopped?
-        puts ui.color("Server #{id} is already stopped", :cyan)
-      else
-        if server.stop
-          puts ui.color("Server stopped", :cyan)
+        if server.stopped?
+          puts ui.color("Server #{id} is already stopped", :cyan)
         else
-          puts ui.error("Failed to stop server")
-          exit 1
+          if server.stop
+            puts ui.color("Server stopped", :cyan)
+          else
+            puts ui.error("Failed to stop server")
+            exit 1
+          end
         end
-      end
-    
-      server.destroy
-      puts ui.color("Deleted server: #{id}", :cyan)
-    
-      puts "\n"
-      confirm("Delete client and node for #{server.name}?")
       
-      node = Chef::Node.load(server.name)
-      puts "deleting node #{node.name}"
-      node.destroy
-      ui.warn("Deleted node named #{node.name}")
+        server.destroy
+        puts ui.color("Deleted server: #{id}", :cyan)
       
-      client = Chef::ApiClient.load(server.name)
-      puts "deleting client #{client.name}"
-      client.destroy
-      ui.warn("Deleted client named #{client.name}")
-    end
-    
-    def msg(label, value)
-      if value && !value.empty?
-        puts "#{ui.color(label, :cyan)}: #{value}"
+        puts "\n"
+        confirm("Delete client and node for #{server.name}?")
+        
+        node = Chef::Node.load(server.name)
+        puts "deleting node #{node.name}"
+        node.destroy
+        ui.warn("Deleted node named #{node.name}")
+        
+        client = Chef::ApiClient.load(server.name)
+        puts "deleting client #{client.name}"
+        client.destroy
+        ui.warn("Deleted client named #{client.name}")
+      end
+      
+      def msg(label, value)
+        if value && !value.empty?
+          puts "#{ui.color(label, :cyan)}: #{value}"
+        end
       end
     end
   end

data/lib/chef/knife/joyent_server_list.rb

@@ -1,50 +1,53 @@
-require File.expand_path(File.dirname(__FILE__) + '/base')
-
-
-module KnifeJoyent
-  class JoyentServerList < Chef::Knife
-
-    include KnifeJoyent::Base
-
-    banner "knife joyent server list <options>"
-
-    def run
-      servers = [
-        ui.color('ID', :bold),
-        ui.color('Name', :bold),
-        ui.color('State', :bold),
-        ui.color('Type', :bold),
-        ui.color('Image', :bold),
-        ui.color('IPs', :bold),
-        ui.color('RAM', :bold),
-        ui.color('Disk', :bold),
-      ]
-
-      self.connection.servers.sort do |a, b|
-        (a.name || '') <=> (b.name || '')
-      end.each do |s|
-        servers << s.id.to_s
-        servers << s.name
-
-        servers << case s.state
-        when 'running'
-          ui.color(s.state, :green)
-        when 'stopping', 'provisioning'
-          ui.color(s.state, :yellow)
-        when 'stopped'
-          ui.color(s.state, :red)
-        else
-          ui.color('unknown', :red)
+require 'chef/knife/joyent_base'
+
+class Chef
+  class Knife
+    class JoyentServerList < Knife
+
+      include Knife::JoyentBase
+
+      banner "knife joyent server list <options>"
+
+      def run
+        servers = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('State', :bold),
+          ui.color('Type', :bold),
+          ui.color('Image', :bold),
+          ui.color('IPs', :bold),
+          ui.color('RAM', :bold),
+          ui.color('Disk', :bold),
+          ui.color('Tags', :bold)
+        ]
+
+        self.connection.servers.sort do |a, b|
+          (a.name || '') <=> (b.name || '')
+        end.each do |s|
+          servers << s.id.to_s
+          servers << s.name
+
+          servers << case s.state
+          when 'running'
+            ui.color(s.state, :green)
+          when 'stopping', 'provisioning'
+            ui.color(s.state, :yellow)
+          when 'stopped'
+            ui.color(s.state, :red)
+          else
+            ui.color('unknown', :red)
+          end
+
+          servers << s.type
+          servers << s.dataset
+          servers << s.ips.join(" ")
+          servers << "#{s.memory/1024} GB".to_s
+          servers << "#{s.disk/1024} GB".to_s
+          servers << s.tags.map { |k, v| "#{k}:#{v}" }.join(' ')
         end
 
-        servers << s.type
-        servers << s.dataset
-        servers << s.ips.join(" ")
-        servers << "#{s.memory/1024} GB".to_s
-        servers << "#{s.disk/1024} GB".to_s
+        puts ui.list(servers, :uneven_columns_across, 9)
       end
-
-      puts ui.list(servers, :uneven_columns_across, 8)
     end
   end
 end