knife-baremetalcloud 0.0.3 → 0.0.4

data/.gitignore

@@ -2,12 +2,8 @@
 *.rbc
 .bundle
 .config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
 coverage
-doc/
+InstalledFiles
 lib/bundler/man
 pkg
 rdoc
@@ -15,3 +11,8 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/README.md

@@ -1,26 +1,136 @@
-# Knife::Baremetalcloud
+Knife baremetalcloud plugin
+===========================
 
-TODO: Write a gem description
+This is the baremetalcloud implementation for Chef's Knife command. The plugin allows Chef users to manage compute nodes on baremetalcloud infrastructure.  
 
-## Installation
+Installation
+------------
 
 Add this line to your application's Gemfile:
 
-    gem 'knife-baremetalcloud'
+    command(gem 'knife-baremetalcloud')
 
 And then execute:
 
-    $ bundle
+    command($ bundle)
 
 Or install it yourself as:
 
-    $ gem install knife-baremetalcloud
+    command($ gem install knife-baremetalcloud)
 
-## Usage
+Usage
+-----
 
-TODO: Write usage instructions here
+## Available commands:
+command(knife baremetalcloud list configurations (options))
+command(knife baremetalcloud list images (options))
+command(knife baremetalcloud list servers (options))
+command(knife baremetalcloud server create (options))
 
-## Contributing
+### List Configurations
+#### Description
+This command list all available server's configurations at baremetalcloud.
+
+
+#### Parameters
+-P, --password PASSWORD          Customer password
+-x, --username USERNAME          Customer username
+
+#### Usage
+command($ knife baremetalcloud list configurations -x USERNAME -P PASSWORD)
+
+#### Example of Output
+Column description:
+<table>
+  <tr>
+    <th>quantity</th><th>configuration</th>
+  </tr>
+</table>
+- *configuration* string is a required argument when running command($ knife baremetalcloud server create).
+
+```
+19	santaclara-ca-usa 2.8 GHz Paxville 2GB DDR-400 73.0GB 3.5" SCSI 10000RPM
+4	santaclara-ca-usa 2.66 GHz Clovertown X5355 8GB DDR2-667 250.0GB 2.5" SATA 7200RPM
+4	santaclara-ca-usa 2.8 GHz Paxville 4GB DDR-400 73.0GB 3.5" SCSI 10000RPM
+5	santaclara-ca-usa 2.66 GHz Woodcrest E5150 8GB DDR2-667 250.0GB 2.5" SATA 7200RPM
+1	miami-fl-usa 2.0 GHz Gainestown E5504 48GB DDR3-1066 120.0GB 2.5" SATA 7200RPM
+3	santaclara-ca-usa 2.66 GHz Clovertown X5355 8GB DDR-400 500.0GB 2.5" SATA 7200RPM
+9	santaclara-ca-usa 2.66 GHz Woodcrest E5150 4GB DDR-400 73.0GB 2.5" SAS 10000RPM
+1	miami-fl-usa 2.8 GHz Paxville 8GB DDR-400 73.0GB 3.5" SCSI 10000RPM
+```
+
+### List Images
+#### Description
+This command list all available images at baremetalcloud.
+
+#### Parameters
+-P, --password PASSWORD          Customer password
+-x, --username USERNAME          Customer username
+
+#### Usage
+command($ knife baremetalcloud list images -x USERNAME -P PASSWORD)
+
+#### Example of Output
+Column description:
+<table>
+  <tr>
+    <th>image size</th><th>image name</th>
+  </tr>
+</table>
+- *image name* string is a required argument when running command($ knife baremetalcloud server create).
+```
+361M	CentOS 5.8
+565M	CentOS 6.2
+319M	XenServer 5.6 SP2
+321M	Ubuntu 11.10
+441M	Ubuntu 12.04
+6.1G	Windows Server 2008 Standard
+3.7G	Windows Server 2003 Standard R2
+183M	SmartOS
+```
+
+### List Servers
+#### Description
+This command list all servers from a customer account at baremetalcloud.
+
+
+#### Parameters
+-P, --password PASSWORD          Customer password
+-x, --username USERNAME          Customer username
+
+#### Usage
+command($ knife baremetalcloud list servers -x USERNAME -P PASSWORD)
+
+#### Example of Output
+Column description:
+<table>
+  <tr>
+    <th>id</th><th>status</th><th>name</th><th>location</th><th>IP</th><th>username</th><th>password</th>
+  </tr>
+</table>
+```
+1234	Active	server-baa	miami-fl-usa	111.222.333.444	ubuntu	PASSWORD
+5678	Active	server-foo	miami-fl-usa	555.666.777.888	root	PASSWORD
+```
+
+### Server Create
+#### Description
+This command add and bootstrap a server at baremetalcloud.
+
+#### Parameters
+-P, --password PASSWORD          Customer password
+-x, --username USERNAME          Customer username
+-C, --configuration CONFIG       Hardware configuration string of the server
+-i, --image IMAGE_NAME           Either baremetalcloud published or customer images
+-n, --name NAME                  Label for the new servers
+-r, --run-list RUN_LIST          Comma separated list of roles/recipes to apply
+
+#### Usage
+command($ knife baremetalcloud list images -x USERNAME -P PASSWORD -C 'santaclara-ca-usa 2.8 GHz Paxville 2GB DDR-400 73.0GB 3.5" SCSI 10000RPM' -i 'CentOS 5.8' -n 'myChefServer' -r 'myrole[cookbook]' )
+
+
+Contributing
+------------
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/knife-baremetalcloud.gemspec

@@ -3,7 +3,7 @@ require File.expand_path('../lib/knife-baremetalcloud/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = ["knife-baremetalcloud"]
-  gem.version       = '0.0.3'
+  gem.version       = '0.0.4'
   gem.authors       = ["Diego Desani"]
   gem.email         = ["diego@newservers.com"]
   gem.summary       = %q{baremetalcloud Compute Support for Chef's Knife Command}

data/lib/chef/knife/{baremetalcloud_list_available_servers.rb → baremetalcloud_list_configurations.rb}

@@ -2,9 +2,9 @@ require 'fog'
 
 class Chef
   class Knife
-    class BaremetalcloudListAvailableServers < Knife
+    class BaremetalcloudListConfigurations < Knife
       
-      banner "knife baremetalcloud list available servers (options)"
+      banner "knife baremetalcloud list configurations (options)"
       
       option :baremetalcloud_username,
         :short => '-x USERNAME',
@@ -16,13 +16,18 @@ class Chef
         :long => '--password PASSWORD',
         :description => 'Customer password'
 
-      def locate_config_value(key)
-        key = key.to_sym
-        config[key] || Chef::Config[:knife][key]
+      # Method to handle baremetalcloud errors
+      def errorHandling(response)
+        # Error handling
+        unless response[:error].nil?
+          puts "#{ui.color("ERROR:", :bold)} #{response[:error][:name]}"
+          puts "Description: #{response[:error][:description]}"
+          exit 1 
+        end
       end
       
-      def run
-        
+      # Method to verify mandatory arguments
+      def verifyArguments
         # Parameters :baremetalcloud_username and :baremetalcloud_password are mandatory
         unless config[:baremetalcloud_username]
           ui.error("--username is a mandatory parameter")
@@ -34,6 +39,14 @@ class Chef
           exit 1
         end
         
+      end
+      
+      # Plugin method called by Knife
+      def run
+        
+        # Verify mandatory arguments
+        verifyArguments
+        
         # Configure the API abstraction @bmc
         @bmc = Fog::Compute.new({
           :bare_metal_cloud_username => config[:baremetalcloud_username],
@@ -41,13 +54,14 @@ class Chef
           :provider => 'BareMetalCloud'
         })
         
-        response = @bmc.list_available_servers.body[:"available-server"]
+        # Get the API response
+        response = @bmc.list_available_servers.body
+        
+        # Error handling
+        errorHandling(response)
         
-       if response.length > 1
-          #puts "#{ui.color("String", :cyan)}\t#{ui.color("Quantity", :cyan)}"
-          response.each do |r|
-            puts "#{r[:configuration]}\t#{r[:quantity]}"
-          end
+        response[:"available-server"].each do |resp|
+          puts "#{resp[:quantity]}\t#{resp[:configuration]}"
         end
         
       end

data/lib/chef/knife/baremetalcloud_list_images.rb

@@ -16,13 +16,23 @@ class Chef
         :long => '--password PASSWORD',
         :description => 'Customer password'
 
-      def locate_config_value(key)
+      def locateConfigValue(key)
         key = key.to_sym
         config[key] || Chef::Config[:knife][key]
       end
       
-      def run
-        
+      # Method to handle baremetalcloud errors
+      def errorHandling(response)
+        # Error handling
+        unless response[:error].nil?
+          puts "#{ui.color("ERROR:", :bold)} #{response[:error][:name]}"
+          puts "Description: #{response[:error][:description]}"
+          exit 1 
+        end
+      end
+      
+      # Method to verify mandatory arguments
+      def verifyArguments
         # Parameters :baremetalcloud_username and :baremetalcloud_password are mandatory
         unless config[:baremetalcloud_username]
           ui.error("--username is a mandatory parameter")
@@ -34,18 +44,30 @@ class Chef
           exit 1
         end
         
+      end
+      
+      # Plugin method called by Knife
+      def run
+        
+        # Verify mandatory arguments
+        verifyArguments
+        
         # Configure the API abstraction @bmc
         @bmc = Fog::Compute.new({
-          :bare_metal_cloud_username => locate_config_value(:baremetalcloud_username),
-          :bare_metal_cloud_password => locate_config_value(:baremetalcloud_password),
+          :bare_metal_cloud_username => locateConfigValue(:baremetalcloud_username),
+          :bare_metal_cloud_password => locateConfigValue(:baremetalcloud_password),
           :provider => 'BareMetalCloud'
         })
         
-        response = @bmc.list_images.body[:image]
-        if response.length > 1
-          #puts "#{ui.color("Id", :cyan)}\t#{ui.color("Name", :cyan)}\t#{ui.color("Size", :cyan)}"
-          response.each do |r|
-            puts "#{r[:id]}\t#{r[:name]}\t#{r[:size]}"
+        # Get the API response
+        response = @bmc.list_images.body
+        
+        # Error handling
+        errorHandling(response)
+        
+        if response[:image].length > 1
+          response[:image].each do |resp|
+            puts "#{resp[:size]}\t#{resp[:name]}"
           end
         end
         

data/lib/chef/knife/baremetalcloud_list_servers.rb

@@ -1,4 +1,4 @@
-  require 'fog'
+require 'fog'
 
 class Chef
   class Knife
@@ -16,13 +16,24 @@ class Chef
         :long => '--password PASSWORD',
         :description => 'Customer password'
 
-      def locate_config_value(key)
+      def locateConfigValue(key)
         key = key.to_sym
         config[key] || Chef::Config[:knife][key]
       end
       
-      def run
-        
+      # Method to handle baremetalcloud errors
+      def errorHandling(response)
+        # Error handling
+        unless response[:error].nil?
+          puts "#{ui.color("ERROR:", :bold)} #{response[:error][:name]}"
+          puts "Description: #{response[:error][:description]}"
+          exit 1 
+        end
+      end
+      
+      
+      # Method to verify mandatory arguments
+      def verifyArguments
         # Parameters :baremetalcloud_username and :baremetalcloud_password are mandatory
         unless config[:baremetalcloud_username]
           ui.error("--username is a mandatory parameter")
@@ -33,24 +44,64 @@ class Chef
           ui.error("--password is a mandatory parameter")
           exit 1
         end
+
+      end
+      
+      # Plugin method called by Knife
+      def run
+        
+        # Verify mandatory arguments
+        verifyArguments
         
         # Configure the API abstraction @bmc
         @bmc = Fog::Compute.new({
-          :bare_metal_cloud_username => locate_config_value(:baremetalcloud_username),
-          :bare_metal_cloud_password => locate_config_value(:baremetalcloud_password),
+          :bare_metal_cloud_username => locateConfigValue(:baremetalcloud_username),
+          :bare_metal_cloud_password => locateConfigValue(:baremetalcloud_password),
           :provider => 'BareMetalCloud'
         })
         
+        # Get the API response
+        response = @bmc.list_servers.body
+        
+        # Error handling
+        errorHandling(response)
         
-        response = @bmc.list_servers.body[:server]
+        # only one server
+        if ( response[:server].class == Hash ) 
+          puts "#{response[:server][:id]}\t#{response[:server][:state]}\t#{response[:server][:name]}\t#{response[:server][:location]}\t#{response[:server][:ip][:address]}\t#{response[:server][:login][:username]}\t#{response[:server][:login][:password]}"
         
-        if response.length > 1
-          response.each do |r|
-            puts "#{r[:id]}\t#{r[:state]}\t#{r[:name]}\t#{r[:location]}\t#{r[:ip][:address]}\t#{r[:login][:username]}\t#{r[:login][:password]}"
+        # more than one server
+        elsif ( response[:server].class == Array ) 
+          response[:server].each do |resp|
+            
+            # 1855 and 1955 have only "system" credentials
+            if ( resp[:login].class == Hash )
+              puts "#{resp[:id]}\t#{resp[:state]}\t#{resp[:name]}\t#{resp[:location]}\t#{resp[:ip][:address]}\t#{resp[:login][:username]}\t#{resp[:login][:password]}"
+           
+            # M600 and M610 have iDRAC credentials
+            else
+              # Username and password variables
+              username = password = nil
+              
+              # Get only system login. Skip iDRAC
+              resp[:login].each do |r|
+                if ( r[:name] == "system")
+                    username = r[:username]
+                    password = r[:password]
+                end
+              end
+              puts "#{resp[:id]}\t#{resp[:state]}\t#{resp[:name]}\t#{resp[:location]}\t#{resp[:ip][:address]}\t#{username}\t#{password}"
+              
+            end
+            
           end
+          
         end
         
       end
+      
     end
+    
   end
+  
 end

data/lib/chef/knife/baremetalcloud_server_create.rb

@@ -6,13 +6,12 @@ class Chef
       
       deps do
         require 'fog'
-        require 'readline'
-        require 'chef/json_compat'
+#        require 'readline'
         require 'chef/knife/bootstrap'
         Chef::Knife::Bootstrap.load_deps
       end
       
-      banner "knife baremetalcloud server create NAME [RUN LIST...] (options)"
+      banner "knife baremetalcloud server create (options)"
       
       attr_accessor :initial_sleep_delay, :bmc
 
@@ -25,11 +24,21 @@ class Chef
         :short => '-P PASSWORD',
         :long => '--password PASSWORD',
         :description => 'Customer password'
+      
+      option :config,
+        :short => '-C CONFIG',
+        :long => '--configuration CONFIG',
+        :description => 'Hardware configuration string of the server'
 
-     option :name,
+      option :name,
         :short => '-n NAME',
         :long => '--name NAME',
         :description => 'Label for the new servers'
+        
+      option :imageName,
+        :short => '-i IMAGE_NAME',
+        :long => '--image IMAGE_NAME',
+        :description => 'Either baremetalcloud published or customer images'
       
       option :run_list,
         :short => "-r RUN_LIST",
@@ -38,18 +47,42 @@ class Chef
         :proc => lambda { |o| o.split(/[\s,]+/) },
         :default => []
           
-      option :location,
-        :short => '-l LOCATION',
-        :long => '--location LOCATION',
-        :description => 'Location of the server (possible values: miami-fl-usa, santaclara-ca-usa)',
-        :default => "miami-fl-usa"
+      
+
+      # Method to check when "system" credentials are available
+      # Node's IP Address is updated
+      def isNodeReady(serverId)
         
-      option :imageName,
-        :short => '-i IMAGE_NAME',
-        :long => '--image IMAGE_NAME',
-        :description => 'Image installed of the server (CentOS5.5x64 or Win2003x64)'
+        # Sleep @initial_sleep_delay seconds
+        sleep @initial_sleep_delay
+        
+        # Get server's status
+        response = @bmc.get_server(serverId).body 
+        
+        # 1855 and 1955 have only "system" credentials
+        if ( response[:server][:login].class == Hash )
+          if ( response[:server][:login][:name] == "system" )
+            config[:ssh_user] = response[:server][:login][:username]
+            config[:ssh_password] = response[:server][:login][:password]
+            config[:chef_node_name] =  response[:server][:ip][:address]
+            return true
+          end
+        elsif ( response[:server][:login].class == Array )  # M600 and M610 have iDRAC credentials
+          response[:server][:login].each do |r|
+            if ( r[:name] == "system")
+              config[:ssh_user] = r[:username]
+              config[:ssh_password] = r[:password]
+              config[:chef_node_name] =  response[:server][:ip][:address]
+              return true
+            end
+          end
+        end
+        false
+      end
 
-      def tcp_test_ssh(hostname)
+      # Method to test if SSH service is running on a node
+      def testSSH(hostname)
+        sleep @initial_sleep_delay
         tcp_socket = TCPSocket.new(hostname, "22")
         readable = IO.select([tcp_socket], nil, nil, 5)
         if readable
@@ -84,49 +117,64 @@ class Chef
           tcp_socket && tcp_socket.close
       end
 
-
-      def locate_config_value(key)
+      # Method to lacate configuration variables
+      def locateConfigValue(key)
         key = key.to_sym
         config[key] || Chef::Config[:knife][key]
       end
       
-      def bootstrap_for_node(public_ip)
-        puts "node bootstrap - #{public_ip}"
+      # Method to configure Knife Bootstrap object
+      def bootstrapNode()
+        puts "Bootstrapping node id #{locateConfigValue(:chef_node_name)}"
         bootstrap = Chef::Knife::Bootstrap.new
-        bootstrap.name_args = [public_ip]
-        bootstrap.config[:run_list] = locate_config_value(:run_list)
-        bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
-        bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
+        bootstrap.name_args = locateConfigValue(:chef_node_name)
+        bootstrap.config[:run_list] = locateConfigValue(:run_list)
+        bootstrap.config[:identity_file] = locateConfigValue[:identity_file]
+        bootstrap.config[:ssh_user] = locateConfigValue(:ssh_user)
+        bootstrap.config[:ssh_password] = locateConfigValue(:ssh_password)
+        bootstrap.config[:use_sudo] = true unless locateConfigValue[:ssh_user] == 'root'
+        bootstrap.config[:environment] = config[:environment]
         bootstrap
       end
 
+      # Method to handle baremetalcloud errors
+      def errorHandling(response)
+        # Error handling
+        unless response[:error].nil?
+          puts "#{ui.color("ERROR:", :bold)} #{response[:error][:name]}"
+          puts "Description: #{response[:error][:description]}"
+          exit 1 
+        end
+      end
 
-
-      def addServer(planId, options = {})
-        puts "Connecting to baremetalcloud"
+      # Method to add baremetalcloud's node and configure
+      def addNode(config, options = {})
         
-        # make the request and get the body
-        response = @bmc.add_server(planId,options).body
+        # Get the API response
+        response = @bmc.add_server_by_configuration(config,options).body
         
-        # Loop while SSH is not available and sleep @initial_sleep_delay seconds
-        print(".") until tcp_test_ssh(response[:server][:ip][:address]) {
-          sleep @initial_sleep_delay
-          print("done")
-        }
+        # Error handling
+        errorHandling(response)
         
-        # Get Server's user and password
-        config[:ssh_user] = response[:server][:login][:username]
-        config[:ssh_password] = response[:server][:login][:password]
+        # get Server id
+        serverId = response[:server][:id]
         
-        # Configure bootstrap and trigger "run" to start up
-        bootstrap_for_node(response[:server][:ip][:address]).run
+        # Loop while server's status is not "Active"
+        print "Waiting for server#{serverId} to be ready"
+        print(".") until isNodeReady(serverId){
+          print "done\n"
+        }
+        
+        # Loop while SSH is not available and sleep @initial_sleep_delay seconds
+        print "Connecting to server#{serverId}" 
+        print(".") until testSSH(response[:server][:ip][:address]) {
+          print "done\n"
+        }
+
       end 
 
-      def run
-        
-        # sleeptime for testing ssh connectivity
-        @initial_sleep_delay = 3
-        
+      # Method to verify mandatory arguments
+      def verifyArguments
         # Parameters :baremetalcloud_username and :baremetalcloud_password are mandatory
         unless config[:baremetalcloud_username]
           ui.error("--username is a mandatory parameter")
@@ -138,40 +186,46 @@ class Chef
           exit 1
         end
         
+        unless config[:config]
+          ui.error("--configuration is a mandatory parameter")
+          exit 1
+        end
+        
+        unless config[:imageName]
+          ui.error("--image is a mandatory parameter")
+          exit 1
+        end
+
+      end
+        
+      # Plugin method called by Knife
+      def run
+        
+        # sleeptime for testing ssh connectivity
+        @initial_sleep_delay = 3
+
+        # Verify mandatory arguments
+        verifyArguments
+        
         # Configure the API abstraction @bmc
         @bmc = Fog::Compute.new({
-          :bare_metal_cloud_username => locate_config_value(:baremetalcloud_username),
-          :bare_metal_cloud_password => locate_config_value(:baremetalcloud_password),
+          :bare_metal_cloud_username => locateConfigValue(:baremetalcloud_username),
+          :bare_metal_cloud_password => locateConfigValue(:baremetalcloud_password),
           :provider => 'BareMetalCloud'
         })
         
-        
-        # Waiting for API rectoring
-        # PlanId = 7
-        ## CentOS small
-        config[:planId] = 7
-        
         # Options
         options = {
-          :location => locate_config_value(:location),
-          :imageName => locate_config_value(:imageName),
-          :name => locate_config_value(:name)
+          :imageName => locateConfigValue(:imageName),
+          :name => locateConfigValue(:name)
         }
         
-        if (config[:planId])
-          addServer(locate_config_value(:planId), options)
-          
-        elsif (config[:config]) # BLOCK WILL BE REMOVED
-          @bmc.list_plans.body[:plan].each do | plan |
-            if plan[:config] == config[:config]
-              addServer(plan[:id], options) # small plan == 7
-            end
-          end
-          
-        else
-          ui.error("PlanId or Configuration is mandatory")
-          exit 1
-        end
+        # Add server method
+        addNode(locateConfigValue(:config), options)
+        
+        # Configure bootstrap and trigger "run" to start up
+        bootstrapNode().run
+        
       end
     end
   end

data/lib/knife-baremetalcloud/version.rb

@@ -1,5 +1,5 @@
 module Knife
   module Baremetalcloud
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: knife-baremetalcloud
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Diego Desani
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-22 00:00:00 Z
+date: 2012-08-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: fog
@@ -44,13 +44,12 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- .project
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - knife-baremetalcloud.gemspec
-- lib/chef/knife/baremetalcloud_list_available_servers.rb
+- lib/chef/knife/baremetalcloud_list_configurations.rb
 - lib/chef/knife/baremetalcloud_list_images.rb
 - lib/chef/knife/baremetalcloud_list_servers.rb
 - lib/chef/knife/baremetalcloud_server_create.rb

data/.project

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>knife-baremetalcloud</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.aptana.ide.core.unifiedBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>com.aptana.ruby.core.rubynature</nature>
-		<nature>com.aptana.projects.webnature</nature>
-	</natures>
-</projectDescription>