knife-opennebula 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c579c6e65a3a6104bbd48c49c8016f340c5e0558
+  data.tar.gz: 9afbd1d86b5ae99eaed6f77bfc1eabcdd816574c
+SHA512:
+  metadata.gz: 48feba45696a64d0263cf48e387833d1c44e55dcbf04060e12de124ddff63253f73b54544fd84334bd0ace2fa347a82f2b7f8fb33c5596e663ddbd178424b222
+  data.tar.gz: 77dd5682f5b7765d964e815bcdf6b849871f3eacb15b3ad68381085bec230a6ec2892a04db4799c0d7a86c857489275f91cd2641d27605b0ba4c63ba34f3a207

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem 'opennebula', '= 4.4.0'
+gem 'chef', '> 10.0.0'
+
+group :test, :development do
+  gem 'rake'
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,109 @@
+# knife plugin for opennebula
+
+## Description
+
+This plugin gives knife the ability to create, bootstrap, and manage OpenNebula Virtual Machines
+
+## Development
+
+To contribute bug patches or new features, you can use the github Pull Request model. It is assumed that code and documentation are contributed under the Apache License 2.0. 
+
+More info:
+* [How to Contribute](http://opennebula.org/software:add-ons#how_to_contribute_to_an_existing_add-on)
+* Support: [OpenNebula user mailing list](http://opennebula.org/community:mailinglists)
+* Development: [OpenNebula developers mailing list](http://opennebula.org/community:mailinglists)
+* Issues Tracking: Github issues (https://github.com/OpenNebula/addon-iscsi/issues)
+
+## Authors
+
+* Leader: Thomas Alrin (alrin@megam.co.in)
+* Kishore Kumar (nkishore@megam.co.in)
+
+## Compatibility
+
+This add-on is compatible with OpenNebula 4.4, 4.6.
+Tested extensively with 4.6 (EC2)
+
+## Requirements
+
+### Chef
+
+Hosted Chef 11.0.x (or) On Premises Chef (http://www.getchef.com/chef/choose-your-version/) configured with a client.
+
+[For more information about Chef](https://learnchef.opscode.com/get-started/)
+
+## Installation
+
+To install the plugin you need to do the following in your workstation:
+
+* `gem install chef`
+* `gem install opennebula`
+* `gem install knife-opennebula`
+
+
+## Configuration
+
+Configuration can be done either of any three ways.
+
+### 1. Configuring the ENV variables
+
+* `export OPENNEBULA_USERNAME="MY_OPENNEBULA_USERNAME"`
+
+* `export OPENNEBULA_PASSWORD="MY_OPENNEBULA_PASSWORD"`
+
+* `export OPENNEBULA_ENDPOINT="MY_OPENNEBULA_ENDPOINT"`
+
+
+### 2. Configuring knife.rb
+* `knife[:opennebula_username] = "MY_OPENNEBULA_USERNAME"`
+
+* `knife[:opennebula_password] = "MY_OPENNEBULA_PASSWORD"`
+
+* `knife[:opennebula_endpoint] = "MY_OPENNEBULA_ENDPOINT"`
+
+### 3. Configure while running commands by passing options
+* `-A` or `--username` -> `OPENNEBULA_USERNAME`
+* `-K` or `--password` -> `OPENNEBULA_PASSWORD`
+* `-e` or `--endpoint` -> `OPENNEBULA_ENDPOINT`
+
+Specific command options can be found by invoking the subcommand with a `--help` flag
+
+## Usage
+
+This plugin provides the following Knife subcommands. Specific command options can be found by invoking the subcommand with a `--help` flag
+
+
+#### To list the virtual resource templates
+
+`knife opennebula template list`
+
+
+#### To list the virual machines
+
+`knife opennebula server list`
+
+
+#### To create a virtual machine by instantiating a template
+
+`knife opennebula server create`
+
+
+#### To undeploy and delete a virtual machine
+
+`knife opennebula server delete SERVER_NAME`
+
+eg:
+
+    knife opennebula template list -A OPENNEBULA_USERNAME -K OPENNEBULA_USER_PASSWORD -e http://my-opennebula.com:2633/RPC2
+    
+    knife opennebula server create -A OPENNEBULA_USERNAME -K OPENNEBULA_USER_PASSWORD -e http://my-opennebula.com:2633/RPC2 -t MY_TEMPLATE_NAME -i IDENTITY_FILE -x USER -r 'role[test]' -N TEST1
+    
+    knife opennebula server list -A OPENNEBULA_USERNAME -K OPENNEBULA_USER_PASSWORD -e http://my-opennebula.com:2633/RPC2
+    
+    knife opennebula server delete SERVER_NAME -A OPENNEBULA_USERNAME -K OPENNEBULA_USER_PASSWORD -e http://my-opennebula.com:2633/RPC2 -P -N NODE_NAME
+
+
+To launch ubuntu-precise template on opennebula host http://canvpn.megam.co.in:2633/RPC2 using private key canvpn.key and role recipe[apt] with name tom
+
+    knife opennebula server create -A oneadmin -K ephamnilnik5 -e http://canvpn.megam.co.in:2633/RPC2 -t Ubuntu-precise -i ~/canvpn.key -x root -r 'recipe[apt]' -N tom
+

data/lib/chef/knife/opennebula_base.rb

@@ -0,0 +1,84 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module OpennebulaBase
+
+    def self.included(includer)
+        includer.class_eval do
+
+         deps do
+        require 'highline'
+        require 'chef/json_compat'
+        Chef::Knife.load_deps
+      end
+
+      option :opennebula_username,
+        :short => "-A OPENNEBULA_USERNAME",
+        :long => "--username OPENNEBULA_USERNAME",
+        :description => "Opennebula user's name",
+        :proc => Proc.new { |user| Chef::Config[:knife][:opennebula_username] = user }
+
+      option :opennebula_passowrd,
+        :short => "-K OPENNEBULA_PASSWORD",
+        :long => "--password OPENNEBULA_PASSWORD",
+        :description => "Opennebula user's password",
+        :proc => Proc.new { |password| Chef::Config[:knife][:opennebula_password] = password }
+
+      option :opennebula_endpoint,
+        :short => "-e OPENNEBULA_ENDPOINT",
+        :long => "--endpoint OPENNEBULA_ENDPOIN",
+        :description => "Opennebula Endpoint",
+        :proc => Proc.new { |endpoint| Chef::Config[:knife][:opennebula_endpoint] = endpoint }
+        end
+      end
+
+
+      require 'opennebula'
+
+      include OpenNebula
+
+      def validate!
+        if (!opennebula_username)
+          ui.error "You did not configure your opennebula_username"
+          exit 1
+        elsif (!opennebula_password)
+          ui.error "You did not configure your opennebula_password"
+          exit 1
+        elsif (!opennebula_endpoint)
+          ui.error "You did not configure your opennebula_endpoint"
+          exit 1
+        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}"
+        end
+      end
+
+      def opennebula_username
+        locate_config_value(:opennebula_username) || ENV['OPENNEBULA_USERNAME']
+      end
+
+      def opennebula_password
+        locate_config_value(:opennebula_password) || ENV['OPENNEBULA_PASSWORD']
+      end
+
+      def opennebula_endpoint
+        locate_config_value(:opennebula_endpoint) || ENV['OPENNEBULA_ENDPOINT']
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        config[key] || Chef::Config[:knife][key]
+      end
+
+    end
+  end
+end

data/lib/chef/knife/opennebula_server_create.rb

@@ -0,0 +1,197 @@
+require 'chef/knife'
+require 'chef/json_compat'
+require 'chef/knife/opennebula_base'
+
+#require_relative 'opennebula_base'
+class Chef
+  class Knife
+    class OpennebulaServerCreate < Knife
+
+      deps do
+        require 'highline'
+        require 'chef/knife/bootstrap'
+        require 'net/ssh'
+        require 'net/ssh/multi'
+        Chef::Knife.load_deps
+      end
+      include Knife::OpennebulaBase
+
+      banner "knife opennebula server create OPTIONS"
+
+      option :opennebula_template,
+        :short => "-t TEMPLATE_NAME",
+        :long => "--template-name TEMPLATE_NAME",
+        :description => "name for the OpenNebula VM TEMPLATE",
+        :required => true,
+        :proc => Proc.new { |template| Chef::Config[:knife][:opennebula_template] = template}
+
+      option :bootstrap,
+        :long => "--[no-]bootstrap",
+        :description => "Bootstrap the server with knife bootstrap, default true",
+        :boolean => true,
+        :default => true
+
+
+      option :ssh_user,
+        :short => "-x USERNAME",
+        :long => "--ssh-user USERNAME",
+        :description => "The authorized user to ssh into the instance, default is 'root'",
+        :default => "root"
+
+
+      option :ssh_port,
+        :short => "-p PORT",
+        :long => "--ssh-port PORT",
+        :description => "The ssh port, default is 22",
+        :default => "22",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+
+      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 :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template; default is 'chef-full'",
+        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
+        :default => "chef-full"
+
+      option :chef_node_name,
+        :short => "-N NAME",
+        :long => "--node-name NAME",
+        :description => "The name for chef node and your vm",
+        :required => true,
+        :proc => Proc.new { |t| Chef::Config[:knife][:chef_node_name] = t }
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of bootstrap template to use, default false",
+        :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+        :default => false
+
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default.",
+        :boolean => true,
+        :default => true
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      def h
+        @highline ||= HighLine.new
+      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
+        puts ui.color("\nServer:", :green)
+        msg_pair("Name", @vm_hash['VM']['name'])
+        msg_pair("IP", @ip_add)
+#Bootstrap VM
+        bootstrap()
+
+        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
+      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
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = @ip_add
+        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[:template_file] = locate_config_value(:template_file)
+        bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || @vm_hash['VM']['name']
+        bootstrap.config[:use_sudo] = true unless bootstrap.config[:ssh_user] == 'root'
+        bootstrap.run
+      end
+
+    end
+  end
+end

data/lib/chef/knife/opennebula_server_delete.rb

@@ -0,0 +1,88 @@
+require 'chef/knife'
+require 'chef/json_compat'
+require 'chef/knife/opennebula_base'
+
+#require_relative 'opennebula_base'
+class Chef
+  class Knife
+    class OpennebulaServerDelete < Knife
+
+      deps do
+        require 'highline'
+        Chef::Knife.load_deps
+      end
+      include Knife::OpennebulaBase
+
+      banner "knife opennebula server delete VM_NAME (OPTIONS)"
+
+      option :purge,
+        :short => "-P",
+        :long => "--purge",
+        :boolean => true,
+        :default => false,
+        :description => "Destroy corresponding node and client on the Chef Server, in addition to destroying the opennebula vm itself.  Assumes node and client have the same name as the server (if not, add the '--node-name' option)."
+
+      option :chef_node_name,
+        :short => "-N NAME",
+        :long => "--node-name NAME",
+        :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)
+          object.destroy
+          ui.warn("Deleted #{type_name} #{name}")
+        rescue Net::HTTPServerException
+          ui.warn("Could not find a #{type_name} named #{name} to delete!")
+        end
+      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'])
+            confirm("Do you really want to delete this server")
+            vm.delete(recreate = false)
+            ui.warn("Deleted server #{@vm_hash['VM']['NAME']}")
+            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
+            else
+              ui.warn("Corresponding node and client for the #{@vm_name} server were not deleted and remain registered with the Chef Server")
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/chef/knife/opennebula_server_list.rb

@@ -0,0 +1,74 @@
+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
+
+      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
+
+        vm_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :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
+
+        end
+        puts ui.color("Virtual Machines Listed Successfully", :green)
+        puts ui.list(vm_list, :uneven_columns_across, 5)
+
+      end
+
+    end
+  end
+end

data/lib/chef/knife/opennebula_template_list.rb

@@ -0,0 +1,61 @@
+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
+
+      def run
+        validate!
+
+        temp_pool = TemplatePool.new(client, -1)
+        rc = temp_pool.info
+        if OpenNebula.is_error?(rc)
+          puts rc.message
+          exit -1
+        end
+
+        # This needs to be fixed as this is tailored for AWS.        
+        temp_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']
+        end
+
+        puts ui.color("VM Templates Listed Successfully", :green)
+        puts ui.list(temp_list, :uneven_columns_across, 4)
+      end
+
+    end
+  end
+end

data/lib/chef/opennebula/version.rb

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

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: knife-opennebula
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kishorekumar Neelamegam, Thomas Alrin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opennebula
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Knife plugin to manage OpenNebula VMs
+email:
+- nkishore@megam.co.in
+- alrin@megam.co.in
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- README.md
+- lib/chef/knife/opennebula_base.rb
+- lib/chef/knife/opennebula_server_create.rb
+- lib/chef/knife/opennebula_server_delete.rb
+- lib/chef/knife/opennebula_server_list.rb
+- lib/chef/knife/opennebula_template_list.rb
+- lib/chef/opennebula/version.rb
+homepage: http://github.com/opennebula/addons-knife
+licenses:
+- Apache V2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Knife plugin to manage OpenNebula VMs
+test_files: []