knife-rackspace 0.5.6 → 0.5.8

data/.gitignore

@@ -0,0 +1,34 @@
+.rake_tasks~
+tags
+coverage
+rdoc
+pkg
+test/tmp
+test/version_tmp
+tmp
+pkg
+*.gem
+*.rbc
+lib/bundler/man
+spec/reports
+.config
+InstalledFiles
+.bundle
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.DS_Store
+Icon?
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+*.swp
+*.swo

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in knife-rackspace.gemspec
+gemspec

data/README.rdoc

@@ -20,12 +20,12 @@ Depending on your system's configuration, you may need to run this command with
 
 In order to communicate with the Rackspace Cloud API you will have to tell Knife about your Username and API Key.  The easiest way to accomplish this is to create some entries in your <tt>knife.rb</tt> file:
 
+    knife[:rackspace_username] = "Your Rackspace API username"
     knife[:rackspace_api_key]  = "Your Rackspace API Key"
-    knife[:rackspace_api_username] = "Your Rackspace API username"
 
 If your knife.rb file will be checked into a SCM system (ie readable by others) you may want to read the values from environment variables:
 
-    knife[:rackspace_api_username] = "#{ENV['RACKSPACE_USERNAME']}"
+    knife[:rackspace_username] = "#{ENV['RACKSPACE_USERNAME']}"
     knife[:rackspace_api_key] = "#{ENV['RACKSPACE_API_KEY']}"
 
 You also have the option of passing your Rackspace API Username/Key into the individual knife subcommands using the <tt>-A</tt> (or <tt>--rackspace-api-username</tt>) <tt>-K</tt> (or <tt>--rackspace-api-key</tt>) command options

data/Rakefile

@@ -0,0 +1,21 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 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 'bundler'
+Bundler::GemHelper.install_tasks

data/knife-rackspace.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "knife-rackspace/version"
+
+Gem::Specification.new do |s|
+  s.name        = "knife-rackspace"
+  s.version     = Knife::Rackspace::VERSION
+  s.has_rdoc = true
+  s.authors     = ["Adam Jacob","Seth Chisamore"]
+  s.email       = ["adam@opscode.com","schisamo@opscode.com"]
+  s.homepage = "http://wiki.opscode.com/display/chef"
+  s.summary = "Rackspace Support for Chef's Knife Command"
+  s.description = s.summary
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE" ]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_dependency "fog", "~> 0.8.2"
+  s.add_dependency "net-ssh", "~> 2.1.3"
+  s.add_dependency "net-ssh-multi", "~> 1.0.1"
+  s.require_paths = ["lib"]
+
+end

data/lib/chef/knife/rackspace_base.rb

@@ -0,0 +1,85 @@
+#
+# 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'
+
+class Chef
+  class Knife
+    module RackspaceBase
+
+      # :nodoc:
+      # Would prefer to do this in a rational way, but can't be done b/c of
+      # Mixlib::CLI's design :(
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'fog'
+            require 'net/ssh/multi'
+            require 'readline'
+            require 'chef/json_compat'
+          end
+
+          option :rackspace_api_key,
+            :short => "-K KEY",
+            :long => "--rackspace-api-key KEY",
+            :description => "Your rackspace API key",
+            :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
+
+          option :rackspace_username,
+            :short => "-A USERNAME",
+            :long => "--rackspace-username USERNAME",
+            :description => "Your rackspace API username",
+            :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_username] = username }
+
+          option :rackspace_api_auth_url,
+            :long => "--rackspace-api-auth-url URL",
+            :description => "Your rackspace API auth url",
+            :default => "auth.api.rackspacecloud.com",
+            :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url }
+        end
+      end
+
+      def connection
+        @connection ||= begin
+          connection = Fog::Compute.new(
+            :provider => 'Rackspace',
+            :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
+            :rackspace_username => (Chef::Config[:knife][:rackspace_username] || Chef::Config[:knife][:rackspace_api_username]),
+            :rackspace_auth_url => Chef::Config[:knife][:rackspace_api_auth_url] || config[:rackspace_api_auth_url]
+          )
+        end
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        Chef::Config[:knife][key] || config[key]
+      end
+
+      def public_dns_name(server)
+        @public_dns_name ||= begin
+          Resolv.getname(server.addresses["public"][0])
+        rescue
+          "#{server.addresses["public"][0].gsub('.','-')}.static.cloud-ips.com"
+        end
+      end
+    end
+  end
+end
+
+

data/lib/chef/knife/rackspace_flavor_list.rb

@@ -16,47 +16,25 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/rackspace_base'
 
 class Chef
   class Knife
     class RackspaceFlavorList < Knife
 
-      deps do
-        require 'fog'
-        require 'chef/json_compat'
-      end
+      include Knife::RackspaceBase
 
       banner "knife rackspace flavor list (options)"
 
-      option :rackspace_api_key,
-        :short => "-K KEY",
-        :long => "--rackspace-api-key KEY",
-        :description => "Your rackspace API key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
-
-      option :rackspace_api_username,
-        :short => "-A USERNAME",
-        :long => "--rackspace-api-username USERNAME",
-        :description => "Your rackspace API username",
-        :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_api_username] = username }
-
-      option :rackspace_api_auth_url,
-        :long => "--rackspace-api-auth-url URL",
-        :description => "Your rackspace API auth url",
-        :default => "auth.api.rackspacecloud.com",
-        :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url }
-
       def run
-
-        connection = Fog::Compute.new(
-          :provider => 'Rackspace',
-          :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
-          :rackspace_username => Chef::Config[:knife][:rackspace_api_username] || Chef::Config[:knife][:rackspace_username],
-          :rackspace_auth_url => Chef::Config[:knife][:rackspace_api_auth_url] || config[:rackspace_api_auth_url]
-        )
-
-        flavor_list = [ ui.color('ID', :bold), ui.color('Name', :bold), ui.color('Architecture', :bold), ui.color('RAM', :bold), ui.color('Disk', :bold) , ui.color('Cores', :bold) ]
+        flavor_list = [ 
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Architecture', :bold),
+          ui.color('RAM', :bold),
+          ui.color('Disk', :bold),
+          ui.color('Cores', :bold)
+        ]
         connection.flavors.sort_by(&:id).each do |flavor|
           flavor_list << flavor.id.to_s
           flavor_list << flavor.name

data/lib/chef/knife/rackspace_image_list.rb

@@ -16,50 +16,27 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/rackspace_base'
 
 class Chef
   class Knife
     class RackspaceImageList < Knife
 
-      deps do
-        require 'fog'
-        require 'chef/json_compat'
-      end
+      include Knife::RackspaceBase
 
       banner "knife rackspace image list (options)"
 
-      option :rackspace_api_key,
-        :short => "-K KEY",
-        :long => "--rackspace-api-key KEY",
-        :description => "Your rackspace API key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
-
-      option :rackspace_api_username,
-        :short => "-A USERNAME",
-        :long => "--rackspace-api-username USERNAME",
-        :description => "Your rackspace API username",
-        :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_api_username] = username }
-
-      option :rackspace_api_auth_url,
-        :long => "--rackspace-api-auth-url URL",
-        :description => "Your rackspace API auth url",
-        :default => "auth.api.rackspacecloud.com",
-        :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url }
-
       def run
-        connection = Fog::Compute.new(
-          :provider => 'Rackspace',
-          :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
-          :rackspace_username => Chef::Config[:knife][:rackspace_api_username] || Chef::Config[:knife][:rackspace_username],
-          :rackspace_auth_url => Chef::Config[:knife][:rackspace_api_auth_url] || config[:rackspace_api_auth_url]
-        )
+        image_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold)
+        ]
 
-        image_list = [ ui.color('ID', :bold), ui.color('Name', :bold) ]
         connection.images.sort_by(&:name).each do |image|
           image_list << image.id.to_s
           image_list << image.name
         end
+
         puts ui.list(image_list, :columns_across, 2)
       end
     end

data/lib/chef/knife/rackspace_server_create.rb

@@ -22,15 +22,15 @@ class Chef
   class Knife
     class RackspaceServerCreate < Knife
 
+      include Knife::RackspaceBase
+
       deps do
-        require 'chef/knife/bootstrap'
-        Chef::Knife::Bootstrap.load_deps
         require 'fog'
-        require 'highline'
         require 'net/ssh/multi'
         require 'readline'
-        require 'resolv'
         require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
       end
 
       banner "knife rackspace server create (options)"
@@ -69,23 +69,10 @@ class Chef
         :long => "--ssh-password PASSWORD",
         :description => "The ssh password"
 
-      option :rackspace_api_key,
-        :short => "-K KEY",
-        :long => "--rackspace-api-key KEY",
-        :description => "Your rackspace API key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
-
-      option :rackspace_api_username,
-        :short => "-A USERNAME",
-        :long => "--rackspace-api-username USERNAME",
-        :description => "Your rackspace API username",
-        :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_api_username] = username }
-
-      option :rackspace_api_auth_url,
-        :long => "--rackspace-api-auth-url URL",
-        :description => "Your rackspace API auth url; default is 'auth.api.rackspacecloud.com'",
-        :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url },
-        :default => "auth.api.rackspacecloud.com"
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
 
       option :prerelease,
         :long => "--prerelease",
@@ -103,11 +90,6 @@ class Chef
         :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
         :default => "ubuntu10.04-gems"
 
-      option :use_sudo,
-        :long => "--sudo",
-        :description => "Execute the bootstrap via sudo",
-        :boolean => false
-
       option :template_file,
         :long => "--template-file TEMPLATE",
         :description => "Full path to location of template to use",
@@ -121,6 +103,13 @@ class Chef
         :proc => lambda { |o| o.split(/[\s,]+/) },
         :default => []
 
+      option :rackspace_metadata,
+        :short => "-M JSON",
+        :long => "--rackspace-metadata JSON",
+        :description => "JSON string version of metadata hash to be supplied with the server create call",
+        :proc => Proc.new { |m| Chef::Config[:knife][:rackspace_metadata] = JSON.parse(m) },
+        :default => ""
+
       def tcp_test_ssh(hostname)
         tcp_socket = TCPSocket.new(hostname, 22)
         readable = IO.select([tcp_socket], nil, nil, 5)
@@ -148,13 +137,6 @@ class Chef
       def run
         $stdout.sync = true
 
-        connection = Fog::Compute.new(
-          :provider => 'Rackspace',
-          :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
-          :rackspace_username => Chef::Config[:knife][:rackspace_api_username] || Chef::Config[:knife][:rackspace_username],
-          :rackspace_auth_url => locate_config_value(:rackspace_api_auth_url)
-        )
-
         unless Chef::Config[:knife][:image]
           ui.error("You have not provided a valid image value.  Please note the short option for this value recently changed from '-i' to '-I'.")
           exit 1
@@ -163,7 +145,8 @@ class Chef
         server = connection.servers.create(
           :name => config[:server_name],
           :image_id => Chef::Config[:knife][:image],
-          :flavor_id => locate_config_value(:flavor)
+          :flavor_id => locate_config_value(:flavor),
+          :metadata => Chef::Config[:knife][:rackspace_metadata]
         )
 
         puts "#{ui.color("Instance ID", :cyan)}: #{server.id}"
@@ -171,6 +154,7 @@ class Chef
         puts "#{ui.color("Name", :cyan)}: #{server.name}"
         puts "#{ui.color("Flavor", :cyan)}: #{server.flavor.name}"
         puts "#{ui.color("Image", :cyan)}: #{server.image.name}"
+        puts "#{ui.color("Metadata", :cyan)}: #{server.metadata}"
 
         print "\n#{ui.color("Waiting server", :magenta)}"
 
@@ -196,6 +180,7 @@ class Chef
         puts "#{ui.color("Name", :cyan)}: #{server.name}"
         puts "#{ui.color("Flavor", :cyan)}: #{server.flavor.name}"
         puts "#{ui.color("Image", :cyan)}: #{server.image.name}"
+        puts "#{ui.color("Metadata", :cyan)}: #{server.metadata}"
         puts "#{ui.color("Public DNS Name", :cyan)}: #{public_dns_name(server)}"
         puts "#{ui.color("Public IP Address", :cyan)}: #{server.addresses["public"][0]}"
         puts "#{ui.color("Private IP Address", :cyan)}: #{server.addresses["private"][0]}"
@@ -216,24 +201,12 @@ class Chef
         bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
         bootstrap.config[:distro] = locate_config_value(:distro)
         # bootstrap will run as root...sudo (by default) also messes up Ohai on CentOS boxes
-        bootstrap.config[:use_sudo] = config[:use_sudo]
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
         bootstrap.config[:template_file] = locate_config_value(:template_file)
         bootstrap.config[:environment] = config[:environment]
         bootstrap
       end
 
-      def locate_config_value(key)
-        key = key.to_sym
-        Chef::Config[:knife][key] || config[key]
-      end
-
-      def public_dns_name(server)
-        @public_dns_name ||= begin
-          Resolv.getname(server.addresses["public"][0])
-        rescue
-          "#{server.addresses["public"][0].gsub('.','-')}.static.cloud-ips.com"
-        end
-      end
     end
   end
 end

data/lib/chef/knife/rackspace_server_delete.rb

@@ -16,76 +16,41 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/rackspace_base'
 
 class Chef
   class Knife
     class RackspaceServerDelete < Knife
-      
-      deps do
-        require 'fog'
-        require 'chef/knife'
-        require 'chef/json_compat'
-        require 'resolv'
-      end
-      
-      banner "knife rackspace server delete SERVER_ID (options)"
-
-      option :rackspace_api_key,
-        :short => "-K KEY",
-        :long => "--rackspace-api-key KEY",
-        :description => "Your rackspace API key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
 
-      option :rackspace_api_username,
-        :short => "-A USERNAME",
-        :long => "--rackspace-api-username USERNAME",
-        :description => "Your rackspace API username",
-        :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_api_username] = username }
+      include Knife::RackspaceBase
 
-      option :rackspace_api_auth_url,
-        :long => "--rackspace-api-auth-url URL",
-        :description => "Your rackspace API auth url",
-        :default => "auth.api.rackspacecloud.com",
-        :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url }
+      banner "knife rackspace server delete SERVER_ID [SERVER_ID] (options)"
 
       def run
-        require 'fog'
-        require 'highline'
-        require 'net/ssh/multi'
-        require 'readline'
-
-        connection = Fog::Compute.new(
-          :provider => 'Rackspace',
-          :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
-          :rackspace_username => Chef::Config[:knife][:rackspace_api_username] || Chef::Config[:knife][:rackspace_username],
-          :rackspace_auth_url => Chef::Config[:knife][:rackspace_api_auth_url] || config[:rackspace_api_auth_url]
-        )
+        @name_args.each do |instance_id|
+          
+          server = connection.servers.get(instance_id)
 
-        server = connection.servers.get(@name_args[0])
+          msg("Instance ID", server.id.to_s)
+          msg("Host ID", server.host_id)
+          msg("Name", server.name)
+          msg("Flavor", server.flavor.name)
+          msg("Image", server.image.name)
+          msg("Public DNS Name", server.addresses["public"][0])
+          msg("Private IP Address", server.addresses["private"][0])
 
-        puts "#{ui.color("Instance ID", :cyan)}: #{server.id}"
-        puts "#{ui.color("Host ID", :cyan)}: #{server.host_id}"
-        puts "#{ui.color("Name", :cyan)}: #{server.name}"
-        puts "#{ui.color("Flavor", :cyan)}: #{server.flavor.name}"
-        puts "#{ui.color("Image", :cyan)}: #{server.image.name}"
-        puts "#{ui.color("Public DNS Name", :cyan)}: #{public_dns_name(server)}"
-        puts "#{ui.color("Public IP Address", :cyan)}: #{server.addresses["public"][0]}"
-        puts "#{ui.color("Private IP Address", :cyan)}: #{server.addresses["private"][0]}"
+          puts "\n"
+          confirm("Do you really want to delete this server")
 
-        puts "\n"
-        confirm("Do you really want to delete this server")
+          server.destroy
 
-        server.destroy
-
-        ui.warn("Deleted server #{server.id} named #{server.name}")
+          ui.warn("Deleted server #{server.id} named #{server.name}")
+        end
       end
 
-      def public_dns_name(server)
-        @public_dns_name ||= begin
-          Resolv.getname(server.addresses["public"][0])
-        rescue
-          "#{server.addresses["public"][0].gsub('.','-')}.static.cloud-ips.com"
+      def msg(label, value)
+        if value && !value.empty?
+          puts "#{ui.color(label, :cyan)}: #{value}"
         end
       end
     end

data/lib/chef/knife/rackspace_server_list.rb

@@ -16,46 +16,18 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/rackspace_base'
 
 class Chef
   class Knife
     class RackspaceServerList < Knife
 
-      deps do
-        require 'fog'
-        require 'chef/json_compat'
-      end
+      include Knife::RackspaceBase
 
       banner "knife rackspace server list (options)"
 
-      option :rackspace_api_key,
-        :short => "-K KEY",
-        :long => "--rackspace-api-key KEY",
-        :description => "Your rackspace API key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
-
-      option :rackspace_api_username,
-        :short => "-A USERNAME",
-        :long => "--rackspace-api-username USERNAME",
-        :description => "Your rackspace API username",
-        :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_api_username] = username }
-
-      option :rackspace_api_auth_url,
-        :long => "--rackspace-api-auth-url URL",
-        :description => "Your rackspace API auth url; default is 'auth.api.rackspacecloud.com'",
-        :default => "auth.api.rackspacecloud.com",
-        :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url }
-
       def run
         $stdout.sync = true
-        
-        connection = Fog::Compute.new(
-          :provider => 'Rackspace',
-          :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
-          :rackspace_username => Chef::Config[:knife][:rackspace_api_username] || Chef::Config[:knife][:rackspace_username],
-          :rackspace_auth_url => Chef::Config[:knife][:rackspace_api_auth_url] || config[:rackspace_api_auth_url]
-        )
 
         server_list = [
           ui.color('Instance ID', :bold),
@@ -73,7 +45,16 @@ class Chef
           server_list << (server.flavor_id == nil ? "" : server.flavor_id.to_s)
           server_list << (server.image_id == nil ? "" : server.image_id.to_s)
           server_list << server.name
-          server_list << (server.state == nil ? "" : server.state.downcase)
+          server_list << begin
+            case server.state.downcase
+            when 'deleted','suspended'
+              ui.color(server.state.downcase, :red)
+            when 'build'
+              ui.color(server.state.downcase, :yellow)
+            else
+              ui.color(server.state.downcase, :green)
+            end
+          end
         end
         puts ui.list(server_list, :columns_across, 7)
 

data/lib/knife-rackspace/version.rb

@@ -1,3 +1,6 @@
-module KnifeRackspace
-  VERSION = "0.5.6"
+module Knife
+  module Rackspace
+    VERSION = "0.5.8"
+    MAJOR, MINOR, TINY = VERSION.split('.')
+  end
 end

metadata

@@ -2,15 +2,16 @@
 name: knife-rackspace
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.6
+  version: 0.5.8
 platform: ruby
 authors: 
 - Adam Jacob
+- Seth Chisamore
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-06-23 00:00:00 -04:00
+date: 2011-07-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,7 +48,9 @@ dependencies:
   type: :runtime
   version_requirements: *id003
 description: Rackspace Support for Chef's Knife Command
-email: adam@opscode.com
+email: 
+- adam@opscode.com
+- schisamo@opscode.com
 executables: []
 
 extensions: []
@@ -56,8 +59,13 @@ extra_rdoc_files:
 - README.rdoc
 - LICENSE
 files: 
+- .gitignore
+- Gemfile
 - LICENSE
 - README.rdoc
+- Rakefile
+- knife-rackspace.gemspec
+- lib/chef/knife/rackspace_base.rb
 - lib/chef/knife/rackspace_flavor_list.rb
 - lib/chef/knife/rackspace_image_list.rb
 - lib/chef/knife/rackspace_server_create.rb