0009-Add-ssh-agent-authentification-options-to-ssh-auth.patch - OpenNebula - OpenNebula Development pages

+        #
         # @param [Hash] default options for path
         # @option options [String] :public_key public key for the user
         # @option options [String] :private_key key private key for the user.
         # @option options [String] :private_key key private key for the user
         # @option options [Boolean] :ssh_agent use ssh agent
         def initialize(options={})
             @private_key = nil
             @public_key  = nil
             @private_key  = read_key(options[:private_key])
             @public_key  = read_key(options[:public_key])
             if @public_key.nil? and not @private_key.nil?
                 # Init ssh keys using private key. public key is extracted in a
                 # format compatible with openssl.
                 @public_key = @private_key.public_key
             if options[:ssh_agent]
                 @agent, @public_key = read_agent_key(options[:private_key])
             else
                 @private_key  = read_key(options[:private_key])
                 @public_key  = read_key(options[:public_key])
                 if @public_key.nil? and not @private_key.nil?
                     # Init ssh keys using private key. public key is extracted in a
                     # format compatible with openssl.
                     @public_key = @private_key.public_key
                 end
             end
             if @private_key.nil? && @public_key.nil?
                 raise "You have to define at least one of the keys"
                 raise "You have to define at least one of the keys, or use a ssh agent"
             end
         end
-...
             end unless path_or_key.nil?
         end
         # Read a public key from an ssh agent and returns it in OpenSSL::PKey::RSA
         # object
         # identity_comment is the comment of the public key to retrieve
         # if nil, the first key is used
         def read_agent_key(identity_comment = nil)
             begin
                 agent = Net::SSH::Authentication::Agent.connect
                 identities = agent.identities
                 public_key = if identity_comment
                                  identities.find do |identity|
                                      identity.comment == identity_comment
                                  end
                              else
                                  identities.first
                              end
                 raise "Cannot find key #{identity_comment} in agent" if public_key.nil? and not identity_comment.nil?
                 [agent, public_key]
             rescue Net::SSH::Authentication::AgentError
                 raise "Cannot connect to ssh agent"
             end
         end
         # Signs data with the private key of the user and returns
         # base 64 encoded signature in a single line
         def sign(data)

             when OpenNebula::User::SSH_AUTH
                 require 'opennebula/ssh_auth'
                 options[:key]  ||= ENV['HOME']+'/.ssh/id_rsa'
                 options[:ssh_agent] ||= true if ENV['SSH_AUTH_SOCK'] and not options[:key]
                 options[:key]  ||= ENV['HOME']+'/.ssh/id_rsa' unless options[:ssh_agent]
                 begin
                     auth = OpenNebula::SshAuth.new(:private_key=>options[:key])
                     auth_options = {}
                     auth_options[:private_key] = options[:key] unless options[:key].nil?
                     auth_options[:ssh_agent] = options[:ssh_agent] unless options[:ssh_agent].nil?
                     auth = OpenNebula::SshAuth.new(auth_options)
                 rescue Exception => e
                     return -1, e.message
                 end
-...
             when OpenNebula::User::SSH_AUTH
                 require 'opennebula/ssh_auth'
                 options[:key]  ||= ENV['HOME']+'/.ssh/id_rsa'
                 options[:ssh_agent] ||= true if ENV['SSH_AUTH_SOCK'] and not options[:key]
                 options[:key]  ||= ENV['HOME']+'/.ssh/id_rsa' unless options[:ssh_agent]
                 begin
                     auth = OpenNebula::SshAuth.new(:private_key=>options[:key])
                     auth_options = {}
                     auth_options[:private_key] = options[:key] unless options[:key].nil?
                     auth_options[:ssh_agent] = options[:ssh_agent] unless options[:ssh_agent].nil?
                     auth = OpenNebula::SshAuth.new(auth_options)
                 rescue Exception => e
                     return -1, e.message
                 end

             :description => "Path to the Private Key of the User"
+        }
         SSH_AGENT={
             :name => "ssh-agent",
             :large => "--ssh-agent",
             :description => "Use an SSH agent to authenticate",
             :proc => lambda { |o, options|
                 options[:ssh_agent] = true
+            }
+        }
         CERT={
             :name => "cert",
             :short => "-c path_to_user_cert_pem",
-...
+        }
         create_options = [READ_FILE, SHA1, SSH, X509, KEY, CERT, DRIVER]
         login_options  = [SSH, X509, X509_PROXY, KEY, CERT, PROXY, TIME]
         login_options  = [SSH, X509, X509_PROXY, KEY, SSH_AGENT, CERT, PROXY, TIME]
         ########################################################################
         # Formatters for arguments
-...
             Creates the Login token for authentication
             Examples:
               oneuser login my_user --ssh --key /tmp/id_rsa --time 72000
               oneuser login my_user --ssh --ssh-agent --time 72000
               oneuser login my_user --ssh --ssh-agent --key /tmp/id_rsa --time 72000
               oneuser login my_user --x509 --cert /tmp/my_cert.pem
                                     --key /tmp/my_key.pk --time 72000
               oneuser login my_user --x509_proxy --proxy /tmp/my_cert.pem
-...
             for the SSH authentication mechanism.
         EOT
         command :key, key_desc, :options=>[KEY] do
         command :key, key_desc, :options=>[KEY, SSH_AGENT] do
             options[:driver] = OpenNebula::User::SSH_AUTH
             helper.password(options)
         end
+    -