oneview-sdk 1.0.0

data/lib/oneview-sdk/client.rb

@@ -0,0 +1,163 @@
+require 'logger'
+require_relative 'config_loader'
+require_relative 'rest'
+require_relative 'ssl_helper'
+
+module OneviewSDK
+  # The client defines the connection to the OneView server and handles communication with it.
+  class Client
+    DEFAULT_API_VERSION = 200
+
+    attr_reader :url, :user, :token, :password, :max_api_version
+    attr_accessor :ssl_enabled, :api_version, :logger, :log_level, :cert_store, :print_wait_dots
+
+    include Rest
+
+    # Create client object, establish connection, and set up logging and api version.
+    # @param [Hash] options the options to configure the client
+    # @option options [Logger] :logger (Logger.new(STDOUT)) Logger object to use.
+    #   Must implement debug(String), info(String), warn(String), error(String), & level=
+    # @option options [Symbol] :log_level (:info) Log level. Logger must define a constant with this name. ie Logger::INFO
+    # @option options [Boolean] :print_wait_dots (false) When true, prints status dots while waiting on tasks to complete.
+    # @option options [String] :url URL of OneView appliance
+    # @option options [String] :user ('Administrator') Username to use for authentication with OneView appliance
+    # @option options [String] :password (ENV['ONEVIEWSDK_PASSWORD']) Password to use for authentication with OneView appliance
+    # @option options [String] :token (ENV['ONEVIEWSDK_TOKEN']) Token to use for authentication with OneView appliance
+    #   Use this OR the username and password (not both). Token has precedence.
+    # @option options [Integer] :api_version (200) API Version to use by default for requests
+    # @option options [Boolean] :ssl_enabled (true) Use ssl for requests? Respects ENV['ONEVIEWSDK_SSL_ENABLED']
+    def initialize(options = {})
+      options = Hash[options.map { |k, v| [k.to_sym, v] }] # Convert string hash keys to symbols
+      @logger = options[:logger] || Logger.new(STDOUT)
+      [:debug, :info, :warn, :error, :level=].each { |m| fail "Logger must respond to #{m} method " unless @logger.respond_to?(m) }
+      @log_level = options[:log_level] || :info
+      @logger.level = @logger.class.const_get(@log_level.upcase) rescue @log_level
+      @print_wait_dots = options.fetch(:print_wait_dots, false)
+      @url = options[:url] || ENV['ONEVIEWSDK_URL']
+      fail 'Must set the url option' unless @url
+      @max_api_version = appliance_api_version
+      if options[:api_version] && options[:api_version].to_i > @max_api_version
+        logger.warn "API version #{options[:api_version]} is greater than the appliance API version (#{@max_api_version})"
+      end
+      @api_version = options[:api_version] || [DEFAULT_API_VERSION, @max_api_version].min
+      @ssl_enabled = true
+      if ENV.key?('ONEVIEWSDK_SSL_ENABLED')
+        if %w(true false 1 0).include?(ENV['ONEVIEWSDK_SSL_ENABLED'])
+          @ssl_enabled = ! %w(false 0).include?(ENV['ONEVIEWSDK_SSL_ENABLED'])
+        else
+          @logger.warn "Unrecognized ssl_enabled value '#{ENV['ONEVIEWSDK_SSL_ENABLED']}'. Valid options are 'true' & 'false'"
+        end
+      end
+      @ssl_enabled = options[:ssl_enabled] unless options[:ssl_enabled].nil?
+      @cert_store = OneviewSDK::SSLHelper.load_trusted_certs if @ssl_enabled
+      @token = options[:token] || ENV['ONEVIEWSDK_TOKEN']
+      return if @token
+      @logger.warn 'User option not set. Using default (Administrator)' unless options[:user] || ENV['ONEVIEWSDK_USER']
+      @user = options[:user] || ENV['ONEVIEWSDK_USER'] || 'Administrator'
+      @password = options[:password] || ENV['ONEVIEWSDK_PASSWORD']
+      fail 'Must set user & password options or token option' unless @password
+      @token = login
+    end
+
+    # Tell OneView to create the resource using the current attribute data
+    # @param [Resource] resource the object to create
+    def create(resource)
+      resource.client = self
+      resource.create
+    end
+
+    # Set attribute data and save to OneView
+    # @param [Resource] resource the object to update
+    def update(resource, attributes = {})
+      resource.client = self
+      resource.update(attributes)
+    end
+
+    # Updates this object using the data that exists on OneView
+    # @param [Resource] resource the object to refresh
+    def refresh(resource)
+      resource.client = self
+      resource.refresh
+    end
+
+    # Deletes this object from OneView
+    # @param [Resource] resource the object to delete
+    def delete(resource)
+      resource.client = self
+      resource.delete
+    end
+
+    # Get array of all resources of a specified type
+    # @param [String] type Resource type
+    # @return [Array<Resource>] Results
+    # @example Get all Ethernet Networks
+    #   networks = @client.get_all('EthernetNetworks')
+    def get_all(type)
+      OneviewSDK.resource_named(type).get_all(self)
+    rescue StandardError
+      raise "Invalid resource type '#{type}'"
+    end
+
+    # Wait for a task to complete
+    # @param [String] task_uri
+    # @raise [RuntimeError] if the task resulted in an error or early termination.
+    # @return [Hash] if the task completed sucessfully, return the task details
+    def wait_for(task_uri)
+      fail 'Must specify a task_uri!' if task_uri.nil? || task_uri.empty?
+      loop do
+        task_uri.gsub!(%r{/https:(.*)\/rest/}, '/rest')
+        task = rest_get(task_uri)
+        body = JSON.parse(task.body)
+        case body['taskState'].downcase
+        when 'completed'
+          return body
+        when 'warning'
+          @logger.warn "Task ended with warning status. Details: #{JSON.pretty_generate(body['taskErrors']) rescue body}"
+          return body
+        when 'error', 'killed', 'terminated'
+          msg = "Task ended with bad state: '#{body['taskState']}'.\nResponse: "
+          msg += body['taskErrors'] ? JSON.pretty_generate(body['taskErrors']) : JSON.pretty_generate(body)
+          fail(msg)
+        else
+          print '.' if @print_wait_dots
+          sleep 10
+        end
+      end
+    end
+
+
+    private
+
+    # Get current api version from the OneView appliance
+    def appliance_api_version
+      options = { 'Content-Type' => :none, 'X-API-Version' => :none, 'auth' => :none }
+      response = rest_api(:get, '/rest/version', options)
+      version = response_handler(response)['currentVersion']
+      fail "Couldn't get API version" unless version
+      version = version.to_i if version.class != Fixnum
+      version
+    rescue
+      @logger.warn "Failed to get OneView max api version. Using default (#{DEFAULT_API_VERSION})"
+      DEFAULT_API_VERSION
+    end
+
+    # Log in to OneView appliance and set max_api_version
+    def login(retries = 2)
+      options = {
+        'body' => {
+          'userName' => @user,
+          'password' => @password,
+          'authLoginDomain' => 'LOCAL'
+        }
+      }
+      response = rest_post('/rest/login-sessions', options)
+      body = response_handler(response)
+      return body['sessionID'] if body['sessionID']
+      fail "\nERROR! Couldn't log into OneView server at #{@url}. Response: #{response}\n#{response.body}"
+    rescue StandardError => e
+      raise e unless retries > 0
+      @logger.debug 'Failed to log in to OneView. Retrying...'
+      return login(retries - 1)
+    end
+  end
+end

data/lib/oneview-sdk/config_loader.rb

@@ -0,0 +1,20 @@
+require 'yaml'
+require 'json'
+
+module OneviewSDK
+  # Configuration helper class to allow .yaml & .json files to be easily used to specify OneView Configuration
+  class Config
+
+    # Load config from .yaml or .json file
+    # @param [String] path The full path to the configuration file
+    # @return [Hash] hash of the configuration
+    def self.load(path)
+      path = File.join(Dir.pwd, path) unless Pathname.new(path).absolute?
+      expanded_path = File.expand_path(path)
+      JSON.parse(IO.read(expanded_path))
+    rescue
+      data = YAML.load_file(expanded_path)
+      Hash[data.map { |k, v| [k.to_s, v] }]
+    end
+  end
+end

data/lib/oneview-sdk/resource.rb

@@ -0,0 +1,313 @@
+require_relative 'client'
+
+# OneviewSDK Resources
+module OneviewSDK
+  # Resource base class that defines all common resource functionality.
+  class Resource
+    BASE_URI = '/rest'.freeze
+
+    attr_accessor \
+      :client,
+      :data,
+      :api_version,
+      :logger
+
+    # Create a resource object, associate it with a client, and set its properties.
+    # @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.
+    def initialize(client, params = {}, api_ver = nil)
+      fail 'Must specify a valid client' unless client.is_a?(OneviewSDK::Client)
+      @client = client
+      @logger = @client.logger
+      @api_version = api_ver || @client.api_version
+      if @api_version > @client.max_api_version
+        fail "#{self.class.name} api_version '#{@api_version}' is greater than the client's max_api_version '#{@client.max_api_version}'"
+      end
+      @data ||= {}
+      set_all(params)
+    end
+
+    # Retrieve resource details based on this resource's name or URI.
+    # @note Name or URI must be specified inside resource
+    # @return [Boolean] Whether or not retrieve was successful
+    def retrieve!
+      fail 'Must set resource name or uri before trying to retrieve!' unless @data['name'] || @data['uri']
+      results = self.class.find_by(@client, name: @data['name']) if @data['name']
+      results = self.class.find_by(@client, uri:  @data['uri'])  if @data['uri'] && (!results || results.empty?)
+      return false unless results.size == 1
+      set_all(results[0].data)
+      true
+    end
+
+    # Check if a resource exists
+    # @note name or uri must be specified inside resource
+    # @return [Boolean] Whether or not resource exists
+    def exists?
+      fail 'Must set resource name or uri before trying to retrieve!' unless @data['name'] || @data['uri']
+      return true if @data['name'] && self.class.find_by(@client, name: @data['name']).size == 1
+      return true if @data['uri']  && self.class.find_by(@client, uri:  @data['uri']).size == 1
+      false
+    end
+
+    # Set the given hash of key-value pairs as resource data attributes
+    # @param [Hash, Resource] params The options for this resource (key-value pairs or Resource object)
+    # @note All top-level keys will be converted to strings
+    # @return [Resource] self
+    def set_all(params = {})
+      params = params.data if params.class <= Resource
+      params = Hash[params.map { |(k, v)| [k.to_s, v] }]
+      params.each { |key, value| set(key.to_s, value) }
+      self
+    end
+
+    # Set a resource attribute with the given value and call any validation method if necessary
+    # @param [String] key attribute name
+    # @param value value to assign to the given attribute
+    # @note Keys will be converted to strings
+    def set(key, value)
+      method_name = "validate_#{key}"
+      send(method_name.to_sym, value) if respond_to?(method_name.to_sym)
+      @data[key.to_s] = value
+    end
+
+    # Run block once for each data key-value pair
+    def each(&block)
+      @data.each(&block)
+    end
+
+    # Access data using hash syntax
+    # @param [String, Symbol] key Name of key to get value for
+    # @return The value of the given key. If not found, returns nil
+    # @note The key will be converted to a string
+    def [](key)
+      @data[key.to_s]
+    end
+
+    # Set data using hash syntax
+    # @param [String, Symbol] key Name of key to set the value for
+    # @param [Object] value to set for the given key
+    # @note The key will be converted to a string
+    # @return The value set for the given key
+    def []=(key, value)
+      set(key, value)
+      value
+    end
+
+    # Check equality of 2 resources. Same as eql?(other)
+    # @param [Resource] other The other resource to check equality for
+    # @return [Boolean] Whether or not the two objects are equal
+    def ==(other)
+      self_state  = instance_variables.sort.map { |v| instance_variable_get(v) }
+      other_state = other.instance_variables.sort.map { |v| other.instance_variable_get(v) }
+      other.class == self.class && other_state == self_state
+    end
+
+    # Check equality of 2 resources. Same as ==(other)
+    # @param [Resource] other The other resource to check equality for
+    # @return [Boolean] Whether or not the two objects are equal
+    def eql?(other)
+      self == other
+    end
+
+    # Check equality of data on other resource with that of this resource.
+    # @note Doesn't check the client, logger, or api_version if another Resource is passed in
+    # @param [Hash, Resource] other Resource or hash to compare key-value pairs with
+    # @example Compare to hash
+    #   myResource = OneviewSDK::Resource.new(client, { name: 'res1', description: 'example'}, 200)
+    #   myResource.like?(description: '') # returns false
+    #   myResource.like?(name: 'res1') # returns true
+    # @return [Boolean] Whether or not the two objects are alike
+    def like?(other)
+      recursive_like?(other, @data)
+    end
+
+    # Create the resource on OneView using the current data
+    # @note Calls the 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, { 'body' => @data }, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+      self
+    end
+
+    # Delete the resource from OneView if it exists, then create it using the current data
+    # @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!
+      temp = self.class.new(@client, @data)
+      temp.delete if temp.retrieve!
+      create
+    end
+
+    # Updates this object using the data that exists on OneView
+    # @note Will overwrite any data that differs from OneView
+    # @return [Resource] self
+    def refresh
+      ensure_client && ensure_uri
+      response = @client.rest_get(@data['uri'], @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+      self
+    end
+
+    # Set data and save to OneView
+    # @param [Hash] attributes The attributes to add/change for this resource (key-value pairs)
+    # @raise [RuntimeError] if the client or uri is not set
+    # @raise [RuntimeError] if the resource save fails
+    # @return [Resource] self
+    def update(attributes = {})
+      set_all(attributes)
+      ensure_client && ensure_uri
+      response = @client.rest_put(@data['uri'], { 'body' => @data }, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+    # Delete resource from OneView
+    # @return [true] if resource was deleted successfully
+    def delete
+      ensure_client && ensure_uri
+      response = @client.rest_delete(@data['uri'], {}, @api_version)
+      @client.response_handler(response)
+      true
+    end
+
+    # Save resource to json or yaml file
+    # @param [String] file_path The full path to the file
+    # @param [Symbol] format The format. Options: [:json, :yml, :yaml]. Defaults to .json
+    # @note If a .yml or .yaml file extension is given in the file_path, the format will be set automatically
+    # @return [True] The Resource was saved successfully
+    def to_file(file_path, format = :json)
+      format = :yml if %w(.yml .yaml).include? File.extname(file_path)
+      temp_data = { type: self.class.name, api_version: @api_version, data: @data }
+      case format.to_sym
+      when :json
+        File.open(file_path, 'w') { |f| f.write(JSON.pretty_generate(temp_data)) }
+      when :yml, :yaml
+        File.open(file_path, 'w') { |f| f.write(temp_data.to_yaml) }
+      else
+        fail "Invalid format: #{format}"
+      end
+      true
+    end
+
+    # Get resource schema
+    # @note This may not be implemented in the API for every resource. Check the API docs
+    # @return [Hash] Schema
+    def schema
+      self.class.schema(@client)
+    end
+
+    # Get resource schema
+    # @param [Client] client
+    # @return [Hash] Schema
+    def self.schema(client)
+      response = client.rest_get("#{self::BASE_URI}/schema", client.api_version)
+      client.response_handler(response)
+    rescue StandardError => e
+      client.logger.error('This resource does not implement the schema endpoint!') if e.message =~ /404 NOT FOUND/
+      raise e
+    end
+
+    # Load resource from a .json or .yaml file
+    # @param [Client] client The client object to associate this resource with
+    # @param [String] file_path The full path to the file
+    # @return [Resource] New resource created from the file contents
+    def self.from_file(client, file_path)
+      resource = OneviewSDK::Config.load(file_path)
+      new(client, resource['data'], resource['api_version'])
+    end
+
+    # Make a GET request to the resource uri and return an array with results matching the search
+    # @param [Client] client
+    # @param [Hash] attributes Hash containing the attributes name and value
+    # @param [String] uri URI of the endpoint
+    # @return [Array<Resource>] Results matching the search
+    def self.find_by(client, attributes, uri = self::BASE_URI)
+      results = []
+      loop do
+        response = client.rest_get(uri)
+        body = client.response_handler(response)
+        members = body['members']
+        break unless members
+        members.each do |member|
+          temp = new(client, member)
+          results.push(temp) if temp.like?(attributes)
+        end
+        break unless body['nextPageUri']
+        uri = body['nextPageUri']
+      end
+      results
+    end
+
+    # Make a GET request to the resource base uri and return an array with all objects of this type
+    # @return [Array<Resource>] Results
+    def self.get_all(client)
+      find_by(client, {})
+    end
+
+    protected
+
+    # Fail unless @client is set for this resource.
+    def ensure_client
+      fail 'Please set client attribute before interacting with this resource' unless @client
+      true
+    end
+
+    # Fail unless @data['uri'] is set for this resource.
+    def ensure_uri
+      fail 'Please set uri attribute before interacting with this resource' unless @data['uri']
+      true
+    end
+
+    # Fail for methods that are not available for one resource
+    def unavailable_method
+      fail "The method ##{caller[0][/`.*'/][1..-2]} is unavailable for this resource"
+    end
+
+    private
+
+    # Recursive helper method for like?
+    # Allows comparison of nested hash structures
+    def recursive_like?(other, data = @data)
+      fail "Can't compare with object type: #{other.class}! Must respond_to :each" unless other.respond_to?(:each)
+      other.each do |key, val|
+        return false unless data && data.respond_to?(:[])
+        if val.is_a?(Hash)
+          return false unless data.class == Hash && recursive_like?(val, data[key.to_s])
+        elsif val != data[key.to_s]
+          return false
+        end
+      end
+      true
+    end
+
+  end
+
+  # Get resource class that matches the type given
+  # @param [String] type Name of the desired class type
+  # @return [Class] Resource class or nil if not found
+  def self.resource_named(type)
+    classes = {}
+    orig_classes = []
+    ObjectSpace.each_object(Class).select { |klass| klass < OneviewSDK::Resource }.each do |c|
+      name = c.name.split('::').last
+      orig_classes.push(name)
+      classes[name.downcase.delete('_').delete('-')] = c
+      classes["#{name.downcase.delete('_').delete('-')}s"] = c
+    end
+    new_type = type.to_s.downcase.gsub(/[ -_]/, '')
+    return classes[new_type] if classes.keys.include?(new_type)
+  end
+end
+
+# Load all resources:
+Dir[File.dirname(__FILE__) + '/resource/*.rb'].each { |file| require file }