oneview-sdk 1.0.0

data/lib/oneview-sdk/resource/volume.rb

@@ -0,0 +1,188 @@
+module OneviewSDK
+  # Volume resource implementation
+  class Volume < Resource
+    BASE_URI = '/rest/storage-volumes'.freeze
+
+    # @!group Validates
+
+    VALID_PROVISION_TYPES = %w(Thin Full).freeze
+    # Validate the type of provisioning
+    # @param [String] value Must be Thin or Full
+    def validate_provisionType(value)
+      fail 'Invalid provision type' unless VALID_PROVISION_TYPES.include?(value)
+    end
+
+    # @!endgroup
+
+    # It's possible to create the volume in 6 different ways:
+    # 1) Common = Storage System + Storage Pool
+    # 2) Template = Storage Volume Template
+    # 3) Common with snapshots = Storage System + Storage Pool + Snapshot Pool
+    # 4) Management = Storage System + wwn
+    # 5) Management by name = Storage System + Storage System Volume Name
+    # 6) Snapshot = Snapshot Pool + Storage Pool + Snapshot
+
+    # Create the volume
+    # @note provisioningParameters are required for creation, but not afterwards; after creation, they will be removed.
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the resource creation fails
+    # @return [Resource] self
+    def create
+      ensure_client
+      response = @client.rest_post(self.class::BASE_URI, { 'body' => @data }, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+      @data.delete('provisioningParameters')
+      self
+    end
+
+    # Delete resource from OneView or from Oneview and storage system
+    # @param [Symbol] flag Delete storage system from Oneview only or in storage system as well
+    # @return [true] if resource was deleted successfully
+    def delete(flag = :all)
+      ensure_client && ensure_uri
+      case flag
+      when :oneview
+        response = @client.rest_api(:delete, @data['uri'], { 'exportOnly' => true }, @api_version)
+        @client.response_handler(response)
+      when :all
+        response = @client.rest_api(:delete, @data['uri'], {}, @api_version)
+        @client.response_handler(response)
+      else
+        fail 'Invalid flag value, use :oneview or :all'
+      end
+      true
+    end
+
+    # Sets the storage system to the volume
+    # @param [OneviewSDK::StorageSystem] storage_system Storage System
+    def set_storage_system(storage_system)
+      assure_uri(storage_system)
+      set('storageSystemUri', storage_system['uri'])
+    end
+
+    # Sets the storage pool to the volume
+    # @param [OneviewSDK::StoragePool] storage_pool Storage pool
+    def set_storage_pool(storage_pool)
+      assure_uri(storage_pool)
+      set('storagePoolUri', storage_pool['uri'])
+    end
+
+    # Adds storage volume template to the volume
+    # @param [OneviewSDK::VolumeTemplate] storage_volume_template Storage Volume Template
+    def set_storage_volume_template(storage_volume_template)
+      assure_uri(storage_volume_template)
+      set('templateUri', storage_volume_template['uri'])
+    end
+
+    # Sets the snapshot pool to the volume
+    # @param [OneviewSDK::StoragePool] storage_pool Storage Pool to use for snapshots
+    def set_snapshot_pool(storage_pool)
+      assure_uri(storage_pool)
+      set('snapshotPoolUri', storage_pool['uri'])
+    end
+
+    # Create a snapshot of the volume
+    # @param [String, OneviewSDK::VolumeSnapshot] snapshot String or OneviewSDK::VolumeSnapshot object
+    # @param [String] description Provide a description
+    # @return [true] if snapshot was created successfully
+    def create_snapshot(snapshot, description = nil)
+      ensure_uri && ensure_client
+      if snapshot.is_a?(OneviewSDK::Resource) || snapshot.is_a?(Hash)
+        name = snapshot[:name] || snapshot['name']
+        description ||= snapshot[:description] || snapshot['description']
+      else
+        name = snapshot
+      end
+      data = {
+        type: 'Snapshot',
+        description: description,
+        name: name
+      }
+      response = @client.rest_post("#{@data['uri']}/snapshots", { 'body' => data }, @api_version)
+      @client.response_handler(response)
+      true
+    end
+
+    # Delete a snapshot of the volume
+    # @param [String] name snapshot name
+    # @return [true] if snapshot was created successfully
+    def delete_snapshot(name)
+      result = get_snapshot(name)
+      response = @client.rest_api(:delete, result['uri'], {}, @api_version)
+      @client.response_handler(response)
+      true
+    end
+
+    # Retrieve snapshot by name
+    # @param [String] name
+    # @return [Hash] snapshot data
+    def get_snapshot(name)
+      results = get_snapshots
+      results.each do |snapshot|
+        return snapshot if snapshot['name'] == name
+      end
+    end
+
+    # Get snapshots of this volume
+    # @return [Array] Array of snapshots
+    def get_snapshots
+      ensure_uri && ensure_client
+      results = []
+      uri = "#{@data['uri']}/snapshots"
+      loop do
+        response = @client.rest_get(uri, @api_version)
+        body = @client.response_handler(response)
+        members = body['members']
+        members.each do |member|
+          results.push(member)
+        end
+        break unless body['nextPageUri']
+        uri = body['nextPageUri']
+      end
+      results
+    end
+
+    # Get all the attachable volumes managed by the appliance
+    # @param [Client] client The client object for the appliance
+    # @return [Array<OneviewSDK::Volume>] Array of volumes
+    def self.get_attachable_volumes(client)
+      results = []
+      uri = "#{BASE_URI}/attachable-volumes"
+      loop do
+        response = client.rest_get(uri)
+        body = client.response_handler(response)
+        members = body['members']
+        members.each { |member| results.push(OneviewSDK::Volume.new(client, member)) }
+        break unless body['nextPageUri']
+        uri = body['nextPageUri']
+      end
+      results
+    end
+
+    # Gets the list of extra managed storage volume paths
+    # @param [OneviewSDK::Client] client
+    # @return response
+    def self.get_extra_managed_volume_paths(client)
+      response = client.rest_get(BASE_URI + '/repair?alertFixType=ExtraManagedStorageVolumePaths')
+      client.response_handler(response)
+    end
+
+    # Removes extra presentation from volume
+    # @return response
+    def repair
+      response = client.rest_post(BASE_URI + '/repair', 'body' => { resourceUri: @data['uri'], type: 'ExtraManagedStorageVolumePaths' })
+      client.response_handler(response)
+    end
+
+    private
+
+    # Verify if the resource has a URI
+    # If not, first it tries to retrieve, and then verify for its existence
+    def assure_uri(resource)
+      resource.retrieve! unless resource['uri']
+      fail "#{resource.class}: #{resource['name']} not found" unless resource['uri']
+    end
+
+  end
+end

data/lib/oneview-sdk/resource/volume_snapshot.rb

@@ -0,0 +1,27 @@
+module OneviewSDK
+  # Volume snapshot resource implementation
+  class VolumeSnapshot < Resource
+    BASE_URI = nil
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['type'] ||= 'Snapshot'
+    end
+
+    def create
+      unavailable_method
+    end
+
+    def update
+      unavailable_method
+    end
+
+    # Sets the volume
+    # @param [OneviewSDK::Volume] volume Volume
+    def set_volume(volume)
+      fail 'Please set the volume\'s uri attribute!' unless volume['uri']
+      @data['storageVolumeUri'] = volume['uri']
+    end
+  end
+end

data/lib/oneview-sdk/resource/volume_template.rb

@@ -0,0 +1,106 @@
+module OneviewSDK
+  # Volume template resource implementation
+  class VolumeTemplate < Resource
+    BASE_URI = '/rest/storage-volume-templates'.freeze
+
+    # Create client object, establish connection, and set up logging and api version.
+    # @param [Client] client The Client object with a connection to the OneView appliance
+    # @param [Hash] params The options for this resource (key-value pairs)
+    # @param [Integer] api_ver The api version to use when interracting with this resource.
+    # Defaults to client.api_version if exists, or OneviewSDK::Client::DEFAULT_API_VERSION.
+    # Defaults type to StorageVolumeTemplate when API version is 120
+    # Defaults type to StorageVolumeTemplateV3 when API version is 200
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values:
+      @data['provisioning'] ||= {}
+      @data['type'] ||= 'StorageVolumeTemplateV3'
+    end
+
+    # @!group Validates
+
+    VALID_REFRESH_STATES = %w(NotRefreshing RefreshFailed RefreshPending Refreshing).freeze
+    # Validate refreshState
+    # @param [String] value NotRefreshing, RefreshFailed, RefreshPending, Refreshing
+    def validate_refreshState(value)
+      fail 'Invalid refresh state' unless VALID_REFRESH_STATES.include?(value)
+    end
+
+    VALID_STATUSES = %w(OK Disabled Warning Critical Unknown).freeze
+    # Validate status
+    # @param [String] value OK, Disabled, Warning, Critical, Unknown
+    def validate_status(value)
+      fail 'Invalid status' unless VALID_STATUSES.include?(value)
+    end
+
+    # @!endgroup
+
+    # Create the resource on OneView using the current data
+    # Adds Accept-Language attribute in the Header equal to "en_US"
+    # @note Calls refresh method to set additional data
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the resource creation fails
+    # @return [Resource] self
+    def create
+      ensure_client
+      response = @client.rest_post(self.class::BASE_URI, { 'Accept-Language' => 'en_US', 'body' => @data }, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Delete volume template from OneView
+    # Adds Accept-Language attribute in the Header equal to "en_US"
+    # @return [TrueClass] if volume template was deleted successfully
+    def delete
+      ensure_client && ensure_uri
+      response = @client.rest_delete(@data['uri'], { 'Accept-Language' => 'en_US' }, @api_version)
+      @client.response_handler(response)
+      true
+    end
+
+    # Update volume template from OneView
+    # Adds Accept-Language attribute in the Header equal to "en_US"
+    # @return [Resource] self
+    def update(attributes = {})
+      set_all(attributes)
+      ensure_client && ensure_uri
+      response = @client.rest_put(@data['uri'], { 'Accept-Language' => 'en_US', 'body' => @data }, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+    # Set storage pool
+    # @param [Boolean] shareable
+    # @param [String] provisionType 'Thin' or 'Full'
+    # @param [String] capacity (in bytes)
+    # @param [OneviewSDK::StoragePool] storage_pool
+    def set_provisioning(shareable, provisionType, capacity, storage_pool)
+      @data['provisioning']['shareable'] = shareable
+      @data['provisioning']['provisionType'] = provisionType
+      @data['provisioning']['capacity'] = capacity
+      storage_pool.retrieve! unless storage_pool['uri']
+      @data['provisioning']['storagePoolUri'] = storage_pool['uri']
+    end
+
+    # Set storage system
+    # @param [OneviewSDK::StorageSystem] storage_system Storage System to be used to create the template
+    def set_storage_system(storage_system)
+      storage_system.retrieve! unless storage_system['uri']
+      @data['storageSystemUri'] = storage_system['uri']
+    end
+
+    # Set snapshot pool
+    # @param [OneviewSDK::StoragePool] storage_pool Storage Pool to generate the template
+    def set_snapshot_pool(storage_pool)
+      storage_pool.retrieve! unless storage_pool['uri']
+      @data['snapshotPoolUri'] = storage_pool['uri']
+    end
+
+    # Get connectable volume templates by its attributes
+    # @param [Hash] attributes Hash containing the attributes name and value
+    def get_connectable_volume_templates(attributes = {})
+      OneviewSDK::Resource.find_by(@client, attributes, BASE_URI + '/connectable-volume-templates')
+    end
+
+  end
+end

data/lib/oneview-sdk/rest.rb

@@ -0,0 +1,163 @@
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'json'
+
+module OneviewSDK
+  # Contains all the methods for making API REST calls
+  module Rest
+    # Make 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
+    # @raise [RuntimeError] if SSL validation of OneView instance's certificate failed
+    # @return [NetHTTPResponse] Response object
+    def rest_api(type, path, options = {}, api_ver = @api_version)
+      @logger.debug "Making :#{type} rest call to #{@url}#{path}"
+      fail 'Must specify path' unless path
+
+      uri = URI.parse(URI.escape(@url + path))
+      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
+
+      request = build_request(type, uri, options, api_ver)
+      response = http.request(request)
+      @logger.debug "  Response: Code=#{response.code}. Headers=#{response.to_hash}\n  Body=#{response.body}"
+      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
+
+    # Make a restful GET request to OneView
+    # Parameters & return value align with those of the {OneviewSDK::Rest::rest_api} method above
+    def rest_get(path, api_ver = @api_version)
+      rest_api(:get, path, {}, api_ver)
+    end
+
+    # Make a restful POST request to OneView
+    # Parameters & return value align with those of the {OneviewSDK::Rest::rest_api} method above
+    def rest_post(path, options = {}, api_ver = @api_version)
+      rest_api(:post, path, options, api_ver)
+    end
+
+    # Make a restful PUT request to OneView
+    # Parameters & return value align with those of the {OneviewSDK::Rest::rest_api} method above
+    def rest_put(path, options = {}, api_ver = @api_version)
+      rest_api(:put, path, options, api_ver)
+    end
+
+    # Make a restful PATCH request to OneView
+    # Parameters & return value align with those of the {OneviewSDK::Rest::rest_api} method above
+    def rest_patch(path, options = {}, api_ver = @api_version)
+      rest_api(:patch, path, options, api_ver)
+    end
+
+    # Make a restful DELETE request to OneView
+    # Parameters & return value align with those of the {OneviewSDK::Rest::rest_api} method above
+    def rest_delete(path, options = {}, api_ver = @api_version)
+      rest_api(:delete, path, options, api_ver)
+    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
+
+    # Handle 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 [RuntimeError] if the request failed
+    # @raise [RuntimeError] if a task was returned that 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
+        return 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']"
+        task = wait_for(response.header['location'])
+        return true unless task['associatedResource'] && task['associatedResource']['resourceUri']
+        resource_data = rest_get(task['associatedResource']['resourceUri'])
+        return JSON.parse(resource_data.body)
+      when RESPONSE_CODE_NO_CONTENT # Synchronous delete
+        return {}
+      when RESPONSE_CODE_BAD_REQUEST
+        fail "400 BAD REQUEST #{response.body}"
+      when RESPONSE_CODE_UNAUTHORIZED
+        fail "401 UNAUTHORIZED #{response.body}"
+      when RESPONSE_CODE_NOT_FOUND
+        fail "404 NOT FOUND #{response.body}"
+      else
+        fail "#{response.code} #{response.body}"
+      end
+    end
+
+
+    private
+
+    # Build 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
+        fail "Invalid rest call: #{type}"
+      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
+
+      filtered_options = options.to_s
+      filtered_options.gsub!(@password, 'filtered') if @password
+      filtered_options.gsub!(@token, 'filtered') if @token
+      @logger.debug "  Options: #{filtered_options}"
+
+      request
+    end
+  end
+end