knife-opennebula 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c579c6e65a3a6104bbd48c49c8016f340c5e0558
-  data.tar.gz: 9afbd1d86b5ae99eaed6f77bfc1eabcdd816574c
+  metadata.gz: 8e44d8c756d827a13b17680c62a2633e0009330f
+  data.tar.gz: 8b525639ad2fdd294dceaad85a600ce89250f1ef
 SHA512:
-  metadata.gz: 48feba45696a64d0263cf48e387833d1c44e55dcbf04060e12de124ddff63253f73b54544fd84334bd0ace2fa347a82f2b7f8fb33c5596e663ddbd178424b222
-  data.tar.gz: 77dd5682f5b7765d964e815bcdf6b849871f3eacb15b3ad68381085bec230a6ec2892a04db4799c0d7a86c857489275f91cd2641d27605b0ba4c63ba34f3a207
+  metadata.gz: 87e6b013604fdfad27c3164fdd7cbea2e1715042859bf012627c7c9fa70a310300e56607b392a049886397b830fa76de17bf288331175f485c55758715ca4bf2
+  data.tar.gz: 45dd682acb0e47f897cd54c91847ee0f456e09cea5c1fee0af5531892c27a85c3a58a28d7658307a553489f79f33b85ac20d14a67622dd3fae65c7d78fecab9c

data/README.md

@@ -16,13 +16,13 @@ More info:
 
 ## Authors
 
-* Leader: Thomas Alrin (alrin@megam.co.in)
-* Kishore Kumar (nkishore@megam.co.in)
+* Leader: Thomas Alrin (thomasalrin@megam.io)
+* Kishore Kumar (nkishore@megam.io)
 
 ## Compatibility
 
-This add-on is compatible with OpenNebula 4.4, 4.6.
-Tested extensively with 4.6 (EC2)
+This add-on is compatible with OpenNebula 4.4, 4.6, 4.12
+
 
 ## Requirements
 
@@ -37,7 +37,6 @@ Hosted Chef 11.0.x (or) On Premises Chef (http://www.getchef.com/chef/choose-you
 To install the plugin you need to do the following in your workstation:
 
 * `gem install chef`
-* `gem install opennebula`
 * `gem install knife-opennebula`
 
 

data/lib/chef/knife/opennebula_base.rb

@@ -1,19 +1,40 @@
-require 'chef/knife'
+#
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, 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.
+#
 
 class Chef
   class Knife
     module OpennebulaBase
 
-    def self.included(includer)
+      # :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 'highline'
-        require 'chef/json_compat'
-        Chef::Knife.load_deps
-      end
+          deps do
+            require 'chef/json_compat'
+            require 'chef/knife'
+            require 'readline'
+	    require 'fog'
+            Chef::Knife.load_deps
+          end
 
-      option :opennebula_username,
+	option :opennebula_username,
         :short => "-A OPENNEBULA_USERNAME",
         :long => "--username OPENNEBULA_USERNAME",
         :description => "Opennebula user's name",
@@ -30,13 +51,21 @@ class Chef
         :long => "--endpoint OPENNEBULA_ENDPOIN",
         :description => "Opennebula Endpoint",
         :proc => Proc.new { |endpoint| Chef::Config[:knife][:opennebula_endpoint] = endpoint }
+
         end
       end
 
+      def connection
+        @connection ||= begin
+                          connection = Fog::Compute.new(
+      :provider => 'OpenNebula',
+      :opennebula_username => locate_config_value(:opennebula_username),
+      :opennebula_password => locate_config_value(:opennebula_password),
+      :opennebula_endpoint => locate_config_value(:opennebula_endpoint)
+            )
+                        end
+      end
 
-      require 'opennebula'
-
-      include OpenNebula
 
       def validate!
         if (!opennebula_username)
@@ -51,11 +80,6 @@ class Chef
         end
       end
 
-      def client
-        cli = Client.new("#{opennebula_username}:#{opennebula_password}", "#{opennebula_endpoint}")
-        cli
-      end
-
       def msg_pair(label, value, color=:cyan)
         if value && !value.to_s.empty?
           ui.info "#{ui.color(label, color)}: #{value}"
@@ -79,6 +103,7 @@ class Chef
         config[key] || Chef::Config[:knife][key]
       end
 
+
     end
   end
 end

data/lib/chef/knife/opennebula_server_create.rb

@@ -1,21 +1,36 @@
+#
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, 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'
 require 'chef/json_compat'
 require 'chef/knife/opennebula_base'
 
-#require_relative 'opennebula_base'
 class Chef
   class Knife
-    class OpennebulaServerCreate < Knife
+     class OpennebulaServerCreate < Knife
 
       deps do
         require 'highline'
         require 'chef/knife/bootstrap'
-        require 'net/ssh'
-        require 'net/ssh/multi'
-        Chef::Knife.load_deps
+	Chef::Knife::Bootstrap.load_deps
       end
       include Knife::OpennebulaBase
-
+  
       banner "knife opennebula server create OPTIONS"
 
       option :opennebula_template,
@@ -31,6 +46,12 @@ class Chef
         :boolean => true,
         :default => true
 
+#It assumes that chef-client already installed in the server (ie) Image has installed with chef-client
+#Chef-client install command
+      option :bootstrap_install_command,
+        :long => "--bootstrap_install_command",
+        :description => "Bootstrap the server with the given chef-client install command",
+        :default => "pwd"
 
       option :ssh_user,
         :short => "-x USERNAME",
@@ -79,6 +100,13 @@ class Chef
         :boolean => true,
         :default => true
 
+      option :json_attributes,
+        :short => "-j JSON",
+        :long => "--json-attributes JSON",
+        :description => "A JSON string to be added to the first run of chef-client",
+        :proc => lambda { |o| JSON.parse(o) }
+
+
       option :identity_file,
         :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
@@ -89,109 +117,113 @@ class Chef
       end
 
       def run
-#Validate opennebula credentials
         validate!
-#Get the template details
-        temp = template("#{locate_config_value(:opennebula_template)}")
-        unless "#{temp.class}" == "OpenNebula::Template"
-          ui.error("Template Not found #{temp.class}")
-          exit 1
-        end
-        puts ui.color("Instantiating Template......", :green)
-#Instantiating a template
-        vm_id = temp.instantiate(name = "#{locate_config_value(:chef_node_name)}", hold = false, template = "")
-#Opennebula error message
-	if OpenNebula.is_error?(vm_id)
-	  ui.error("Some problem in instantiating template")
-	  ui.error("#{vm_id.message}")
-          exit -1
-        end
-        unless "#{vm_id.class}" == "Fixnum"
-          ui.error("Some problem in instantiating template")
-          exit 1
-        end
-        puts ui.color("Template Instantiated, and a VM created with id #{vm_id}", :green)
-        puts ui.color("Fetching ip address of the VM ", :magenta)
-#Get the VM details
-        vir_mac = virtual_machine("#{vm_id}")
-        unless "#{vir_mac.class}" == "OpenNebula::VirtualMachine"
-          ui.error("Some problem in Getting Virtual Machine")
-          exit 1
-        end
-        @vm_hash = vir_mac.to_hash
-#VM can have more ip addresses. Priority to get vm ip is AWS_IP_ADDRESS, MEGAM_IP_ADDRESS and PRIVATE_IP_ADDRESS.
-	if @vm_hash['VM']['TEMPLATE'].has_key?('AWS_IP_ADDRESS')
-		@ip_add = @vm_hash['VM']['TEMPLATE']['AWS_IP_ADDRESS']
-	else
-		@ip_add = @vm_hash['VM']['USER_TEMPLATE']['MEGAM_IP_ADDRESS']
-	end
+	validate_flavor!
+
+	newvm = connection.servers.new
+
+newvm.flavor = connection.flavors.get(flavor.id)
+
+# set the name of the vm
+newvm.name = locate_config_value(:chef_node_name)
+
+newvm.flavor.vcpu = 1
+
+vm = newvm.save
+	
+ser = server(vm.id)
         puts ui.color("\nServer:", :green)
-        msg_pair("Name", @vm_hash['VM']['name'])
-        msg_pair("IP", @ip_add)
+        msg_pair("VM Name", ser.name)
+        msg_pair("VM ID", ser.id)
+        msg_pair("IP", ser.ip)
+	msg_pair("Template", flavor.name)
+
+        print "\n#{ui.color("Waiting for server", :magenta)}"
+
+        # wait for it to be ready to do stuff
+        ser.wait_for { print "."; ready? }
+
+        puts("\n")
+        # hack to ensure the nodes have had time to spin up
+        print(".")
+        sleep 30
+        print(".")
+
+        print(".") until tcp_test_ssh(ser.ip) {
+          sleep @initial_sleep_delay ||= 10
+          puts("done")
+        }
+
 #Bootstrap VM
-        bootstrap()
+        bootstrap(ser.ip)
 
         puts ui.color("Server:", :green)
-        msg_pair("Name", @vm_hash['VM']['name'])
-        msg_pair("IP", @ip_add)
-      end
-
-      def virtual_machine(id)
-        vm_pool = VirtualMachinePool.new(client, -1)
-        rc = vm_pool.info
-        if OpenNebula.is_error?(rc)
-          puts rc.message
-          exit -1
-        end
-        vm_pool.each do |vm|
-          if "#{vm.id}" == "#{id}"
-            v_hash = vm.to_hash
-#Sleep untill get the VM's Ip address from either vm_hash['VM']['TEMPLATE']['AWS_IP_ADDRESS'] or vm_hash['VM']['USER_TEMPLATE']['MEGAM_IP_ADDRESS'].
-#vm_hash['VM']['USER_TEMPLATE']['MEGAM_IP_ADDRESS'] can be set by onegate. In our case, we get that ip from vpn.
-            if v_hash['VM']['TEMPLATE'].has_key?('AWS_IP_ADDRESS') || v_hash['VM']['USER_TEMPLATE'].has_key?('MEGAM_IP_ADDRESS')
-              @re_obj = vm
-            else
-              sleep 1
-              print "."
-              virtual_machine("#{vm.id}")
-            end
-          end
-        end
-        @re_obj
+        msg_pair("Name", ser.name)
+        msg_pair("IP", ser.ip)
+        msg_pair("Environment", config[:environment] || '_default')
+        msg_pair("Run List", config[:run_list].join(', '))
+        msg_pair("JSON Attributes",config[:json_attributes]) unless !config[:json_attributes] || config[:json_attributes].empty?
       end
 
-      def template(name)
-#Searching user's vm template
-        puts ui.color("Locating Template......", :green)
-        temp_pool = TemplatePool.new(client, -1)
-        rc = temp_pool.info
-        if OpenNebula.is_error?(rc)
-          puts rc.message
-          exit -1
-        end
-        temp_pool.each do |temp|
-          if "#{temp.name}" == "#{name}"
-            puts ui.color("Template Found.", :green)
-          return temp
-          end
-        end
-      end
 
-      def bootstrap
+      def bootstrap(ip)
         bootstrap = Chef::Knife::Bootstrap.new
-        bootstrap.name_args = @ip_add
+        bootstrap.name_args = ip
         bootstrap.config[:run_list] = locate_config_value(:run_list)
         bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
         bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
         bootstrap.config[:identity_file] = locate_config_value(:identity_file)
         bootstrap.config[:distro] = locate_config_value(:distro)
         bootstrap.config[:host_key_verify] = config[:host_key_verify]
+        bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes) || {}
         bootstrap.config[:template_file] = locate_config_value(:template_file)
-        bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || @vm_hash['VM']['name']
+        bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name)
+        bootstrap.config[:bootstrap_install_command] = locate_config_value(:bootstrap_install_command)
         bootstrap.config[:use_sudo] = true unless bootstrap.config[:ssh_user] == 'root'
         bootstrap.run
       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("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
+
+      def flavor
+        @flavor ||= connection.flavors.get_by_name(locate_config_value(:opennebula_template))
+	@flavor[0]
+      end
+
+      def server(id)
+        @server ||= connection.servers.get(id)
+      end
+
+      def validate_flavor!
+        if flavor.nil?
+          ui.error("You have not provided a valid Template NAme. Please note the options for this value are -t or --template-name.")
+          exit 1
+        end
+      end
+
+
     end
   end
 end

data/lib/chef/knife/opennebula_server_delete.rb

@@ -1,18 +1,36 @@
-require 'chef/knife'
-require 'chef/json_compat'
+#
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, 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/node'
+require 'chef/api_client'
 require 'chef/knife/opennebula_base'
 
-#require_relative 'opennebula_base'
 class Chef
   class Knife
-    class OpennebulaServerDelete < Knife
+     class OpennebulaServerDelete < Knife
 
       deps do
         require 'highline'
         Chef::Knife.load_deps
       end
-      include Knife::OpennebulaBase
 
+      include Knife::OpennebulaBase
+  
       banner "knife opennebula server delete VM_NAME (OPTIONS)"
 
       option :purge,
@@ -28,10 +46,6 @@ class Chef
         :description => "The name of the node and client to delete, if it differs from the server name.  Only has meaning when used with the '--purge' option."
 
 
-      def h
-        @highline ||= HighLine.new
-      end
-
       def destroy_item(klass, name, type_name)
         begin
           object = klass.load(name)
@@ -42,45 +56,51 @@ class Chef
         end
       end
 
+      def h
+        @highline ||= HighLine.new
+      end
+
+
       def run
+
         validate!
-        if @name_args.empty?
-          ui.error("no vm name is specific")
-          exit -1
-        else
-          @vm_name = @name_args[0]
-        end
-        vm_pool = VirtualMachinePool.new(client, -1)
-        rc = vm_pool.info
-        if OpenNebula.is_error?(rc)
-          puts rc.message
-          exit -1
-        end
 
-        vm_pool.each do |vm|
-          if "#{vm.name}" == "#{@vm_name}"
-            @vm_hash = vm.to_hash
-            msg_pair("VM ID", @vm_hash['VM']['ID'])
-            msg_pair("VM Name", @vm_hash['VM']['NAME'])
-            msg_pair("Availability Zone", @vm_hash['VM']['TEMPLATE']['AWS_AVAILABILITY_ZONE'])
-            msg_pair("Public IP Address", @vm_hash['VM']['TEMPLATE']['AWS_IP_ADDRESS'])
+        @name_args.each do |instance_id|
+          begin
+
+        #Fetch instance_id by name of the server =====> MEGAM SYSTEMS CODE START
+        connection.servers.all.each do |ser|
+        	if ser.name.to_s == "#{instance_id}"
+        		instance_id = ser.id
+		end
+	end
+	#=====> MEGAM SYSTEMS CODE END
+
+            server = connection.servers.get(instance_id)
+
+            msg_pair("VM ID", server.id)
+            msg_pair("VM Name", server.name)
+            msg_pair("IP Address", server.ip)
+
+            puts "\n"
             confirm("Do you really want to delete this server")
-            vm.delete(recreate = false)
-            ui.warn("Deleted server #{@vm_hash['VM']['NAME']}")
+
+            server.destroy
+
+            ui.warn("Deleted server #{server.id}")
+
             if config[:purge]
-              if config[:chef_node_name]
-                thing_to_delete = config[:chef_node_name]
-                destroy_item(Chef::Node, thing_to_delete, "node")
-                destroy_item(Chef::ApiClient, thing_to_delete, "client")
-              else
-                ui.error("Please Provide Chef NODE_NAME in -N")
-              end
+              thing_to_delete = config[:chef_node_name] || instance_id
+              destroy_item(Chef::Node, thing_to_delete, "node")
+              destroy_item(Chef::ApiClient, thing_to_delete, "client")
             else
-              ui.warn("Corresponding node and client for the #{@vm_name} server were not deleted and remain registered with the Chef Server")
+              ui.warn("Corresponding node and client for the #{instance_id} server were not deleted and remain registered with the Chef Server")
             end
+
+          rescue NoMethodError
+            ui.error("Could not locate server '#{instance_id}'.")
           end
         end
-
       end
 
     end

data/lib/chef/knife/opennebula_server_list.rb

@@ -1,74 +1,53 @@
+#
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, 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'
 require 'chef/json_compat'
 require 'chef/knife/opennebula_base'
 
-#require_relative 'opennebula_base'
 class Chef
   class Knife
     class OpennebulaServerList < Knife
 
-      deps do
-        require 'highline'
-        Chef::Knife.load_deps
-      end
       include Knife::OpennebulaBase
 
-      banner "knife opennebula server list OPTIONS"
-
-      def h
-        @highline ||= HighLine.new
-      end
+      banner "knife opennebula server list (options)"
 
       def run
-        validate!
 
-        vm_pool = VirtualMachinePool.new(client, -1)
-        rc = vm_pool.info
-        if OpenNebula.is_error?(rc)
-          puts rc.message
-          exit -1
-        end
-
-        # TO-DO: This is tailored for AWS, need to be fixed, just so it works for private/public
+        validate!
 
-        vm_list = [
+        server_list = [
           ui.color('ID', :bold),
           ui.color('Name', :bold),
+          ui.color('IP', :bold),
           ui.color('Memory', :bold),
-          ui.color('Cpu', :bold),
-          #ui.color('AWS_ZONE', :bold),
-          #ui.color('INSTANCE_TYPE', :bold),
-          #ui.color('IP', :bold),
-          #ui.color('AWS_Key', :bold),
           ui.color('State', :bold)]
-        vm_pool.each do |vm|
-          vm_hash = vm.to_hash
-          vm_list << vm_hash['VM']['ID']
-          vm_list << vm_hash['VM']['NAME']
-          vm_list << vm_hash['VM']['TEMPLATE']['MEMORY']
-          vm_list << vm_hash['VM']['TEMPLATE']['CPU']
-          #vm_list << vm_hash['VM']['TEMPLATE']['AWS_AVAILABILITY_ZONE'] if vm_hash['VM']['TEMPLATE'].has_key?('AWS_AVAILABILITY_ZONE')
-          #vm_list << vm_hash['VM']['TEMPLATE']['AWS_INSTANCE_TYPE'] if vm_hash['VM']['TEMPLATE'].has_key?('AWS_INSTANCE_TYPE')
-          #vm_list << vm_hash['VM']['TEMPLATE']['AWS_IP_ADDRESS'] if vm_hash['VM']['TEMPLATE'].has_key?('AWS_IP_ADDRESS')
-          #vm_list << vm_hash['VM']['TEMPLATE']['AWS_KEY_NAME'] if vm_hash['VM']['TEMPLATE'].has_key?('AWS_KEY_NAME')
-          vm_list <<  begin
-            state = vm_hash['VM']['STATE']
-            case state
-            when '1'
-              ui.color(state, :red)
-            when '2'
-              ui.color(state, :yellow)
-            else
-            ui.color(state, :green)
-            end
-          end
 
+        connection.servers.all.each do |server|
+          server_list << "#{server.id.to_s}"
+          server_list << server.name
+          server_list << server.ip
+          server_list << "#{server.memory.to_s}"
+          server_list << server.state
         end
-        puts ui.color("Virtual Machines Listed Successfully", :green)
-        puts ui.list(vm_list, :uneven_columns_across, 5)
-
+        puts ui.list(server_list, :uneven_columns_across, 5)
       end
-
     end
   end
 end

data/lib/chef/knife/opennebula_template_list.rb

@@ -1,61 +1,51 @@
+#
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, 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'
 require 'chef/json_compat'
 require 'chef/knife/opennebula_base'
 
-#require_relative 'opennebula_base'
 class Chef
   class Knife
     class OpennebulaTemplateList < Knife
 
-      deps do
-        require 'highline'
-        Chef::Knife.load_deps
-      end
       include Knife::OpennebulaBase
 
-      banner "knife opennebula template list OPTIONS"
-
-      def h
-        @highline ||= HighLine.new
-      end
+      banner "knife opennebula template list (options)"
 
       def run
-        validate!
 
-        temp_pool = TemplatePool.new(client, -1)
-        rc = temp_pool.info
-        if OpenNebula.is_error?(rc)
-          puts rc.message
-          exit -1
-        end
+        validate!
 
-        # This needs to be fixed as this is tailored for AWS.        
-        temp_list = [
+        flavor_list = [
           ui.color('ID', :bold),
           ui.color('Name', :bold),
-          #ui.color('AMI', :bold),
-          #ui.color('INSTANCE_TYPE', :bold),
-          #ui.color('KEY_PAIR', :bold),
-          #ui.color('SECURITY_GROUP', :bold),
           ui.color('CPU', :bold),
           ui.color('MEMORY', :bold)]
 
-        temp_pool.each do |temp|
-          temp_hash = temp.to_hash
-          temp_list << temp_hash['VMTEMPLATE']['ID']
-          temp_list << temp_hash['VMTEMPLATE']['NAME']
-          #temp_list << temp_hash['VMTEMPLATE']['TEMPLATE']['EC2']['AMI'] if temp_hash['VMTEMPLATE']['TEMPLATE'].has_key?('EC2')
-          #temp_list << temp_hash['VMTEMPLATE']['TEMPLATE']['EC2']['INSTANCETYPE'] if temp_hash['VMTEMPLATE']['TEMPLATE'].has_key?('EC2')
-          #temp_list << temp_hash['VMTEMPLATE']['TEMPLATE']['EC2']['KEYPAIR'] if temp_hash['VMTEMPLATE']['TEMPLATE'].has_key?('EC2')
-          #temp_list << temp_hash['VMTEMPLATE']['TEMPLATE']['EC2']['SECURITYGROUPS'] if temp_hash['VMTEMPLATE']['TEMPLATE'].has_key?('EC2')
-          temp_list << temp_hash['VMTEMPLATE']['TEMPLATE']['CPU']
-          temp_list << temp_hash['VMTEMPLATE']['TEMPLATE']['MEMORY']
+        connection.flavors.all.each do |flavor|
+          flavor_list << flavor.id
+          flavor_list << flavor.name
+          flavor_list << flavor.cpu.to_s
+          flavor_list << "#{flavor.memory.to_s} MB"
         end
-
-        puts ui.color("VM Templates Listed Successfully", :green)
-        puts ui.list(temp_list, :uneven_columns_across, 4)
+        puts ui.list(flavor_list, :uneven_columns_across, 4)
       end
-
     end
   end
 end

data/lib/chef/opennebula/version.rb

@@ -1,5 +1,5 @@
 class Chef
   class Opennebula
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,31 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: knife-opennebula
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kishorekumar Neelamegam, Thomas Alrin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-06 00:00:00.000000000 Z
+date: 2015-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: opennebula
+  name: fog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.26.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.26.0
 - !ruby/object:Gem::Dependency
   name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: opennebula
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -54,8 +68,8 @@ dependencies:
         version: '0'
 description: Knife plugin to manage OpenNebula VMs
 email:
-- nkishore@megam.co.in
-- alrin@megam.co.in
+- nkishore@megam.io
+- thomasalrin@megam.io
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -89,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Knife plugin to manage OpenNebula VMs