test-oneview 5.18.0

data/lib/oneview-sdk/resource_helper.rb

@@ -0,0 +1,44 @@
+# (C) Copyright 2017 Hewlett Packard Enterprise Development LP
+#
+# 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.
+
+module OneviewSDK
+  # Contains helper methods to include certain functionalities on resources
+  module ResourceHelper
+    # Contains helper method to call patch endpoint of resource
+    module PatchOperation
+      # Performs a specific patch operation for the given resource.
+      # If the resource supports the particular operation, the operation is performed
+      # and a response is returned to the caller with the results.
+      # @param [String] operation The operation to be performed
+      # @param [String] path The path of operation
+      # @param [String] value The value
+      # @note This attribute is subject to incompatible changes in future release versions, including redefinition or removal.
+      def patch(operation, path, value = nil, header_options = {})
+        ensure_client && ensure_uri
+        options = { 'body' => [op: operation, path: path, value: value] }
+        options = options.merge(header_options)
+        response = @client.rest_patch(@data['uri'], options, @api_version)
+        @client.response_handler(response)
+      end
+    end
+
+    # Contains helper method to call configuration endpoint of resource
+    module ConfigurationOperation
+      # Reapplies the configuration
+      def configuration
+        ensure_client && ensure_uri
+        response = @client.rest_put(@data['uri'] + '/configuration', {}, @api_version)
+        new_data = @client.response_handler(response)
+        set_all(new_data)
+      end
+    end
+  end
+end

data/lib/oneview-sdk/rest.rb

@@ -0,0 +1,292 @@
+# (C) Copyright 2016 Hewlett Packard Enterprise Development LP
+#
+# 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 'addressable'
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'json'
+require 'net/http/post/multipart'
+
+module OneviewSDK
+  # Contains all of the methods for making API REST calls
+  module Rest
+    READ_TIMEOUT = 300 # in seconds, 5 minutes
+
+    # Makes a restful API request to OneView
+    # @param [Symbol] type The rest method/type Options: [:get, :post, :delete, :patch, :put]
+    # @param [String] path The path for the request. Usually starts with "/rest/"
+    # @param [Hash] options The options for the request
+    # @option options [String] :body Hash to be converted into json and set as the request body
+    # @option options [String] :Content-Type ('application/json') Set to nil or :none to have this option removed
+    # @option options [Integer] :X-API-Version (client.api_version) API version to use for this request
+    # @option options [Integer] :auth (client.token) Authentication token to use for this request
+    # @param [Integer] api_ver The api version to use when interracting with this resource
+    # @param [Integer] redirect_limit Number of redirects it is allowed to follow
+    # @raise [OpenSSL::SSL::SSLError] if SSL validation of OneView instance's certificate failed
+    # @return [NetHTTPResponse] Response object
+    def rest_api(type, path, options = {}, api_ver = @api_version, redirect_limit = 3)
+      @logger.debug "Making :#{type} rest call to #{@url}#{path}"
+      raise InvalidRequest, 'Must specify path' unless path
+      uri = URI.parse(Addressable::URI.escape(@url + path))
+      http = build_http_object(uri)
+      request = build_request(type, uri, options.dup, api_ver)
+      response = http.request(request)
+      @logger.debug "  Response: Code=#{response.code}. Headers=#{response.to_hash}\n  Body=#{response.body}"
+      if response.class <= Net::HTTPRedirection && redirect_limit > 0 && response['location']
+        @logger.debug "Redirecting to #{response['location']}"
+        return rest_api(type, response['location'], options, api_ver, redirect_limit - 1)
+      end
+      response
+    rescue OpenSSL::SSL::SSLError => e
+      msg = 'SSL verification failed for request. Please either:'
+      msg += "\n  1. Install the certificate into your system's cert store"
+      msg += ". Using cert store: #{ENV['SSL_CERT_FILE']}" if ENV['SSL_CERT_FILE']
+      msg += "\n  2. Run oneview-sdk-ruby cert import #{@url}"
+      msg += "\n  3. Set the :ssl_enabled option to false for your client (NOT RECOMMENDED)"
+      @logger.error msg
+      raise e
+    end
+
+    # Makes a restful GET request to OneView
+    # @param [String] path The path for the request. Usually starts with "/rest/"
+    # @param [Hash] options The options for the request
+    # @option options [String] :Content-Type ('application/json') Set to nil or :none to have this option removed
+    # @option options [Integer] :X-API-Version (client.api_version) API version to use for this request
+    # @option options [Integer] :auth (client.token) Authentication token to use for this request
+    # @param [Integer] api_ver The api version to use when interracting with this resource
+    # @return [NetHTTPResponse] Response object
+    def rest_get(path, options = {}, api_ver = @api_version)
+      rest_api(:get, path, options, api_ver)
+    end
+
+    # Makes a restful POST request to OneView
+    # @param [String] path The path for the request. Usually starts with "/rest/"
+    # @param [Hash] options The options for the request
+    # @option options [String] :body Hash to be converted into json and set as the request body
+    # @option options [String] :Content-Type ('application/json') Set to nil or :none to have this option removed
+    # @option options [Integer] :X-API-Version (client.api_version) API version to use for this request
+    # @option options [Integer] :auth (client.token) Authentication token to use for this request
+    # @param [Integer] api_ver The api version to use when interracting with this resource
+    # @return [NetHTTPResponse] Response object
+    def rest_post(path, options = {}, api_ver = @api_version)
+      rest_api(:post, path, options, api_ver)
+    end
+
+    # Makes a restful PUT request to OneView
+    # @param [String] path The path for the request. Usually starts with "/rest/"
+    # @param [Hash] options The options for the request
+    # @option options [String] :body Hash to be converted into json and set as the request body
+    # @option options [String] :Content-Type ('application/json') Set to nil or :none to have this option removed
+    # @option options [Integer] :X-API-Version (client.api_version) API version to use for this request
+    # @option options [Integer] :auth (client.token) Authentication token to use for this request
+    # @param [Integer] api_ver The api version to use when interracting with this resource
+    # @return [NetHTTPResponse] Response object
+    def rest_put(path, options = {}, api_ver = @api_version)
+      rest_api(:put, path, options, api_ver)
+    end
+
+    # Makes a restful PATCH request to OneView
+    # @param [String] path The path for the request. Usually starts with "/rest/"
+    # @param [Hash] options The options for the request
+    # @option options [String] :body Hash to be converted into json and set as the request body
+    # @option options [String] :Content-Type ('application/json') Set to nil or :none to have this option removed
+    # @option options [Integer] :X-API-Version (client.api_version) API version to use for this request
+    # @option options [Integer] :auth (client.token) Authentication token to use for this request
+    # @param [Integer] api_ver The api version to use when interracting with this resource
+    # @return [NetHTTPResponse] Response object
+    def rest_patch(path, options = {}, api_ver = @api_version)
+      rest_api(:patch, path, options, api_ver)
+    end
+
+    # Makes a restful DELETE request to OneView
+    # @param [String] path The path for the request. Usually starts with "/rest/"
+    # @param [Hash] options The options for the request
+    # @option options [String] :body Hash to be converted into json and set as the request body
+    # @option options [String] :Content-Type ('application/json') Set to nil or :none to have this option removed
+    # @option options [Integer] :X-API-Version (client.api_version) API version to use for this request
+    # @option options [Integer] :auth (client.token) Authentication token to use for this request
+    # @param [Integer] api_ver The api version to use when interracting with this resource
+    # @return [NetHTTPResponse] Response object
+    def rest_delete(path, options = {}, api_ver = @api_version)
+      rest_api(:delete, path, options, api_ver)
+    end
+
+    # Uploads a file to a specific uri
+    # @param [String] file_path
+    # @param [String] path The url path starting with "/"
+    # @param [Hash] options The options for the request. Default is {}.
+    # @option options [String] :body Hash to be converted into json and set as the request body
+    # @option options [String] :header Hash to be converted into json and set as the request header
+    # @option options [String] :file_name String that defines the new file name
+    # @param [Integer] timeout The number of seconds to wait for completing the request. Default is 300.
+    # @return [Hash] The parsed JSON body of response
+    def upload_file(file_path, path, options = {}, timeout = READ_TIMEOUT)
+      raise NotFound, "ERROR: File '#{file_path}' not found!" unless File.file?(file_path)
+      options = Hash[options.map { |k, v| [k.to_s, v] }]
+      body_params = options['body'] || {}
+      headers_params = options['header'] || {}
+      headers = {
+        'Content-Type' => 'multipart/form-data',
+        'X-Api-Version' => @api_version.to_s,
+        'auth' => @token
+      }
+      headers.merge!(headers_params)
+
+      File.open(file_path) do |file|
+        name_to_show = options['file_name'] || File.basename(file_path)
+        body_params['file'] = UploadIO.new(file, 'application/octet-stream', name_to_show)
+
+        uri = URI.parse(Addressable::URI.escape(@url + path))
+        http_request = build_http_object(uri)
+        http_request.read_timeout = timeout
+
+        req = Net::HTTP::Post::Multipart.new(
+          uri.path,
+          body_params,
+          headers
+        )
+
+        http_request.start do |http|
+          begin
+            response = http.request(req)
+            return response_handler(response)
+          rescue Net::ReadTimeout
+            raise "The connection was closed because the timeout of #{timeout} seconds has expired."\
+              'You can specify the timeout in seconds by passing the timeout on the method call.'\
+              'Interrupted file uploads may result in corrupted file remaining in the appliance.'\
+              'HPE recommends checking the appliance for corrupted file and removing it.'
+          end
+        end
+      end
+    end
+
+    # Download a file from a specific uri
+    # @param [String] path The url path starting with "/"
+    # @param [String] local_drive_path Path to save file downloaded
+    # @return [Boolean] if file was downloaded
+    def download_file(path, local_drive_path)
+      uri = URI.parse(Addressable::URI.escape(@url + path))
+      http_request = build_http_object(uri)
+      req = build_request(:get, uri, {}, @api_version.to_s)
+
+      http_request.start do |http|
+        http.request(req) do |res|
+          response_handler(res) unless res.code.to_i.between?(200, 204)
+          File.open(local_drive_path, 'wb') do |file|
+            res.read_body do |segment|
+              file.write(segment)
+            end
+          end
+        end
+      end
+      true
+    end
+
+    RESPONSE_CODE_OK           = 200
+    RESPONSE_CODE_CREATED      = 201
+    RESPONSE_CODE_ACCEPTED     = 202
+    RESPONSE_CODE_NO_CONTENT   = 204
+    RESPONSE_CODE_BAD_REQUEST  = 400
+    RESPONSE_CODE_UNAUTHORIZED = 401
+    RESPONSE_CODE_NOT_FOUND    = 404
+
+    # Handles the response from a rest call.
+    #   If an asynchronous task was started, this waits for it to complete.
+    # @param [HTTPResponse] response HTTP response
+    # @param [Boolean] wait_on_task Wait on task (or just return task details)
+    # @raise [OneviewSDK::OneViewError] if the request failed or a task did not complete successfully
+    # @return [Hash] The parsed JSON body
+    def response_handler(response, wait_on_task = true)
+      case response.code.to_i
+      when RESPONSE_CODE_OK # Synchronous read/query
+        begin
+          return JSON.parse(response.body)
+        rescue JSON::ParserError => e
+          @logger.warn "Failed to parse JSON response. #{e}"
+          return response.body
+        end
+      when RESPONSE_CODE_CREATED # Synchronous add
+        JSON.parse(response.body)
+      when RESPONSE_CODE_ACCEPTED # Asynchronous add, update or delete
+        return JSON.parse(response.body) unless wait_on_task
+        @logger.debug "Waiting for task: response.header['location']"
+        uri = response.header['location'] || JSON.parse(response.body)['uri'] # If task uri is not returned in header
+        task = wait_for(uri)
+        return true unless task['associatedResource'] && task['associatedResource']['resourceUri']
+        resource_data = rest_get(task['associatedResource']['resourceUri'])
+        JSON.parse(resource_data.body)
+      when RESPONSE_CODE_NO_CONTENT # Synchronous delete
+        {}
+      when RESPONSE_CODE_BAD_REQUEST
+        BadRequest.raise! "400 BAD REQUEST #{response.body}", response
+      when RESPONSE_CODE_UNAUTHORIZED
+        Unauthorized.raise! "401 UNAUTHORIZED #{response.body}", response
+      when RESPONSE_CODE_NOT_FOUND
+        NotFound.raise! "404 NOT FOUND #{response.body}", response
+      else
+        RequestError.raise! "#{response.code} #{response.body}", response
+      end
+    end
+
+
+    private
+
+    # Builds a http object using the data given
+    def build_http_object(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.scheme == 'https'
+      if @ssl_enabled
+        http.cert_store = @cert_store if @cert_store
+      else http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      http.read_timeout = @timeout if @timeout # Timeout for a request
+      http.open_timeout = @timeout if @timeout # Timeout for a connection
+      http
+    end
+
+    # Builds a request object using the data given
+    def build_request(type, uri, options, api_ver)
+      case type.downcase.to_sym
+      when :get
+        request = Net::HTTP::Get.new(uri.request_uri)
+      when :post
+        request = Net::HTTP::Post.new(uri.request_uri)
+      when :put
+        request = Net::HTTP::Put.new(uri.request_uri)
+      when :patch
+        request = Net::HTTP::Patch.new(uri.request_uri)
+      when :delete
+        request = Net::HTTP::Delete.new(uri.request_uri)
+      else
+        raise InvalidRequest, "Invalid rest method: #{type}. Valid methods are: get, post, put, patch, delete"
+      end
+
+      options['X-API-Version'] ||= api_ver
+      options['auth'] ||= @token
+      options['Content-Type'] ||= 'application/json'
+      options.delete('Content-Type')  if [:none, 'none', nil].include?(options['Content-Type'])
+      options.delete('X-API-Version') if [:none, 'none', nil].include?(options['X-API-Version'])
+      options.delete('auth')          if [:none, 'none', nil].include?(options['auth'])
+      options.each do |key, val|
+        if key.to_s.downcase == 'body'
+          request.body = val.to_json rescue val
+        else
+          request[key] = val
+        end
+      end
+
+      @logger.debug "  Options: #{options}" # Warning: This may include passwords and tokens
+
+      request
+    end
+  end
+end

data/lib/oneview-sdk/scmb.rb

@@ -0,0 +1,71 @@
+# (c) Copyright 2017 Hewlett Packard Enterprise Development LP
+#
+# 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_relative 'client'
+require 'bunny'
+
+module OneviewSDK
+  # State Schange Message Bus (SCMB) helper
+  module SCMB
+    DEFAULT_ROUTING_KEY = 'scmb.#'.freeze
+
+    # Create a new connection to the message bus
+    # @param [OneviewSDK::Client] client The client object for the OneView appliance
+    # @param [Hash] opts Connection options (passed to Bunny.new). Defaults:
+    #     port: 5671
+    #     auth_mechanism: 'EXTERNAL'
+    #     tls: true
+    #     verify_peer: client.ssl_enabled
+    #     tls_cert: (retrieved automatically from OneView)
+    #     tls_key: (retrieved automatically from OneView)
+    #     tls_ca_certificates: System default CA (unless verify_peer is false)
+    #   See http://rubybunny.info/articles/connecting.html for more details & options
+    # @return [Bunny::Session] Connection to the message bus
+    def self.new_connection(client, opts = {})
+      con_opts = {
+        port: 5671,
+        auth_mechanism: 'EXTERNAL',
+        tls: true,
+        verify_peer: client.ssl_enabled,
+        logger: client.logger
+      }
+      con_opts.merge!(opts)
+      con_opts[:host] = URI.parse(client.url).host
+      unless con_opts[:tls_cert] && con_opts[:tls_key]
+        kp = get_or_create_keypair(client)
+        con_opts[:tls_cert] = kp['base64SSLCertData']
+        con_opts[:tls_key] = kp['base64SSLKeyData']
+      end
+      Bunny.new(con_opts).start
+    end
+
+    # Retrieve or create the default RabbitMQ keypair
+    # @param [OneviewSDK::Client] client The client object for the OneView appliance
+    # @return [Hash] Keypair details
+    def self.get_or_create_keypair(client)
+      client.response_handler(client.rest_get('/rest/certificates/client/rabbitmq/keypair/default'))
+    rescue OneviewSDK::NotFound # Create the keypair if it doesn't exist
+      client.logger.info('RabbitMQ default keypair not found. Creating it now.')
+      opts = { commonName: 'default', type: 'RabbitMqClientCertV2' }
+      client.response_handler(client.rest_post('/rest/certificates/client/rabbitmq', body: opts))
+      # Retrieve the created key
+      client.response_handler(client.rest_get('/rest/certificates/client/rabbitmq/keypair/default'))
+    end
+
+    # @param [Bunny::Session] Connection to the message bus. See ::new_connection
+    # @return [Bunny::Queue] Queue listening to the specified routing key
+    def self.new_queue(connection, routing_key = DEFAULT_ROUTING_KEY)
+      ch = connection.create_channel
+      q = ch.queue('')
+      q.bind('scmb', routing_key: routing_key)
+    end
+  end
+end

data/lib/oneview-sdk/ssl_helper.rb

@@ -0,0 +1,87 @@
+# (C) Copyright 2016 Hewlett Packard Enterprise Development LP
+#
+# 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 'addressable'
+require 'uri'
+require 'net/http'
+require 'openssl'
+
+module OneviewSDK
+  # SSL certificate helper
+  module SSLHelper
+    CERT_STORE = File.join(Dir.home, '/.oneview-sdk-ruby/trusted_certs.cer')
+
+    # Load any trusted certs and add them to the default SSL cert store.
+    #   Looks for a file at ~/.oneview-sdk-ruby/trusted_certs.cer
+    #   Note: File must be readable and parseable by X509::Store.add_file method
+    # @return [X509::Store] cert_store
+    def self.load_trusted_certs
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      begin
+        store.add_file(CERT_STORE) if File.file?(CERT_STORE)
+      rescue StandardError => e
+        puts "WARNING: Failed to load certificate store file at #{CERT_STORE} \n  Message: #{e.message}"
+      end
+      store
+    rescue StandardError => e
+      puts "WARNING: Failure in #{self}##{__method__} \n  Message: #{e.message}"
+      nil
+    end
+
+    # Check to see if the OneView instance's certificate is trusted
+    # @param [String] url URL for the OneView Instance to be added
+    # @return [Boolean] Whether or not certificate is trusted
+    # @raise [OneviewSDK::InvalidURL] if the url is invalid
+    def self.check_cert(url)
+      uri = URI.parse(Addressable::URI.escape(url))
+      raise InvalidURL, "Invalid url '#{url}'" unless uri.host
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.scheme == 'https'
+      trusted_certs = load_trusted_certs
+      http.cert_store = trusted_certs if trusted_certs
+      http.request(Net::HTTP::Get.new(uri.request_uri))
+      true
+    rescue OpenSSL::SSL::SSLError
+      false
+    end
+
+    # Fetch and add the SSL certificate for the OneView instance to the trusted certs store.
+    #   Creates/modifies file at ~/.oneview-sdk-ruby/trusted_certs.cer
+    # @param [String] url URL for the OneView Instance to be added
+    # @raise [OneviewSDK::InvalidURL] if the url is invalid
+    def self.install_cert(url)
+      uri = URI.parse(Addressable::URI.escape(url))
+      raise InvalidURL, "Invalid url '#{url}'" unless uri.host
+      options = { use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE }
+      pem = Net::HTTP.start(uri.host, uri.port, options) do |http|
+        http.peer_cert.to_pem
+      end
+      raise "Could not download cert from #{url}. You may have to do it manually, and append it to '#{CERT_STORE}'" if pem.nil?
+
+      name = "OneView at #{url}"
+      content = "\n#{name}\n"
+      content << "#{'=' * name.length}\n"
+      content << pem
+
+      cert_dir = File.dirname(CERT_STORE)
+      Dir.mkdir(cert_dir) unless File.directory?(cert_dir)
+      if File.file?(CERT_STORE) && File.read(CERT_STORE).include?(pem)
+        puts 'Cert store already contains this certificate. Skipped!'
+        false
+      else
+        File.open(CERT_STORE, 'a') { |f| f.write content }
+        puts "Cert added to '#{CERT_STORE}'. Cert Info: #{content}"
+        true
+      end
+    end
+  end
+end