oneview-sdk 1.0.0

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

@@ -0,0 +1,92 @@
+module OneviewSDK
+  # Logical enclosure group resource implementation
+  class LogicalInterconnectGroup < Resource
+    BASE_URI = '/rest/logical-interconnect-groups'.freeze
+    attr_reader :bay_count
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values:
+      @data['enclosureType'] ||= 'C7000'
+      @data['state'] ||= 'Active'
+      @data['uplinkSets'] ||= []
+      @data['type'] ||= 'logical-interconnect-groupV3'
+      @data['interconnectMapTemplate'] ||= {}
+      @data['interconnectMapTemplate']['interconnectMapEntryTemplates'] ||= []
+
+      # User friendly values:
+      @bay_count = 8
+
+      # Create all entries if empty
+      parse_interconnect_map_template if @data['interconnectMapTemplate']['interconnectMapEntryTemplates'] == []
+    end
+
+    # Add an interconnect
+    # @param [Fixnum] bay Bay number
+    # @param [String] type Interconnect type
+    def add_interconnect(bay, type)
+      @data['interconnectMapTemplate']['interconnectMapEntryTemplates'].each do |entry|
+        entry['logicalLocation']['locationEntries'].each do |location|
+          if location['type'] == 'Bay' && location['relativeValue'] == bay
+            entry['permittedInterconnectTypeUri'] = OneviewSDK::Interconnect.get_type(@client, type)['uri']
+          end
+        end
+      end
+    rescue StandardError
+      list = OneviewSDK::Interconnect.get_types(@client).map { |t| t['name'] }
+      raise "Interconnect type #{type} not found! Supported types: #{list}"
+    end
+
+    # Add an uplink set
+    # @param [OneviewSDK::LIGUplinkSet] uplink_set
+    def add_uplink_set(uplink_set)
+      @data['uplinkSets'] << uplink_set.data
+    end
+
+    # Get the default settings
+    def get_default_settings
+      get_uri = self.class::BASE_URI + '/defaultSettings'
+      response = @client.rest_get(get_uri, @api_version)
+      @client.response_handler(response)
+    end
+
+    # Get settings
+    def get_settings
+      get_uri = @data['uri'] + '/settings'
+      response = @client.rest_get(get_uri, @api_version)
+      @client.response_handler(response)
+    end
+
+    # Saves the current data attributes to the Logical Interconnect Group
+    # @return Updated instance of the Logical Interconnect Group
+    def update(attributes = {})
+      set_all(attributes)
+      update_options = {
+        'If-Match' =>  @data.delete('eTag'),
+        'Body' => @data
+      }
+      response = @client.rest_put(@data['uri'], update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    private
+
+    def parse_interconnect_map_template
+      1.upto(@bay_count) do |bay_number|
+        entry = {
+          'logicalDownlinkUri' => nil,
+          'logicalLocation' => {
+            'locationEntries' => [
+              { 'relativeValue' => bay_number, 'type' => 'Bay' },
+              { 'relativeValue' => 1, 'type' => 'Enclosure' }
+            ]
+          },
+          'permittedInterconnectTypeUri' => nil
+        }
+        @data['interconnectMapTemplate']['interconnectMapEntryTemplates'] << entry
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,88 @@
+module OneviewSDK
+  # Server hardware resource implementation
+  class ServerHardware < Resource
+    BASE_URI = '/rest/server-hardware'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['type'] ||= 'server-hardware-4'
+    end
+
+    # @!group Validates
+
+    VALID_LICENSING_INTENTS = ['OneView', 'OneViewNoiLO', 'OneViewStandard', nil].freeze
+    def validate_licensingIntent(value)
+      fail 'Invalid licensingIntent' unless VALID_LICENSING_INTENTS.include?(value)
+    end
+
+    VALID_CONFIGURATION_STATES = ['Managed', 'Monitored', nil].freeze
+    def validate_configurationState(value)
+      fail 'Invalid configurationState' unless VALID_CONFIGURATION_STATES.include?(value)
+    end
+
+    # @!endgroup
+
+    def create
+      ensure_client
+      required_attributes = %w(hostname username password licensingIntent)
+      required_attributes.each { |k| fail "Missing required attribute: '#{k}'" unless @data.key?(k) }
+
+      optional_attrs = %w(configurationState force restore)
+      temp_data = @data.select { |k, _v| required_attributes.include?(k) || optional_attrs.include?(k) }
+      response = @client.rest_post(self.class::BASE_URI, { 'body' => temp_data }, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+      %w(username password hostname).each { |k| @data.delete(k) } # These are no longer needed
+      self
+    end
+
+    def update(*)
+      fail 'Method not available for this resource!'
+    end
+
+    # Power on the server hardware
+    # @param [String] force Use 'PressAndHold' action
+    # @return [Boolean] Whether or not server was powered on
+    def power_on(force = false)
+      set_power_state('on', force)
+    end
+
+    # Power off the server hardware
+    # @param [String] force Use 'PressAndHold' action
+    # @return [Boolean] Whether or not server was powered off
+    def power_off(force = false)
+      set_power_state('off', force)
+    end
+
+    private
+
+    # Set power state. Takes into consideration the current state and does the right thing
+    def set_power_state(state, force)
+      refresh
+      return true if @data['powerState'].downcase == state
+      @logger.debug "Powering #{state} server hardware '#{@data['name']}'. Current state: '#{@data['powerState']}'"
+
+      action = 'PressAndHold' if force
+      action ||= case @data['powerState'].downcase
+                 when 'poweringon', 'poweringoff' # Wait
+                   sleep 5
+                   return set_power_state(state, force)
+                 when 'resetting'
+                   if state == 'on' # Wait
+                     sleep 5
+                     return set_power_state(state, force)
+                   end
+                   'PressAndHold'
+                 when 'unknown' then state == 'on' ? 'ColdBoot' : 'PressAndHold'
+                 else 'MomentaryPress'
+                 end
+      options = { 'body' => { powerState: state.capitalize, powerControl: action } }
+      response = @client.rest_put("#{@data['uri']}/powerState", options)
+      body = @client.response_handler(response)
+      set_all(body)
+      true
+    end
+
+  end
+end

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

@@ -0,0 +1,27 @@
+module OneviewSDK
+  # Server hardware type resource implementation
+  class ServerHardwareType < Resource
+    BASE_URI = '/rest/server-hardware-types'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['type'] ||= 'server-hardware-type-4'
+    end
+
+    def create
+      unavailable_method
+    end
+
+    def update(attributes = {})
+      set_all(attributes)
+      ensure_client && ensure_uri
+      data = @data.select { |k, _v| %w(name description).include?(k) }
+      data['description'] ||= ''
+      response = @client.rest_put(@data['uri'], { 'body' => data }, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+module OneviewSDK
+  # Server profile resource implementation
+  class ServerProfile < Resource
+    BASE_URI = '/rest/server-profiles'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['type'] ||= 'ServerProfileV5'
+    end
+
+    # Get available server hardware for this template
+    # @return [Array<OneviewSDK::ServerHardware>] Array of ServerHardware resources that matches this
+    #   profile's server hardware type and enclosure group and who's state is 'NoProfileApplied'
+    def available_hardware
+      ensure_client
+      fail 'Must set @data[\'serverHardwareTypeUri\']' unless @data['serverHardwareTypeUri']
+      fail 'Must set @data[\'enclosureGroupUri\']' unless @data['enclosureGroupUri']
+      params = {
+        state: 'NoProfileApplied',
+        serverHardwareTypeUri: @data['serverHardwareTypeUri'],
+        serverGroupUri: @data['enclosureGroupUri']
+      }
+      OneviewSDK::ServerHardware.find_by(@client, params)
+    rescue StandardError => e
+      raise "Failed to get available hardware. Message: #{e.message}"
+    end
+
+    def validate_serverProfileTemplateUri(*)
+      fail "Templates only exist on api version >= 200. Resource version: #{@api_version}" if @api_version < 200
+    end
+
+    def validate_templateCompliance(*)
+      fail "Templates only exist on api version >= 200. Resource version: #{@api_version}" if @api_version < 200
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module OneviewSDK
+  # Server profile template resource implementation
+  class ServerProfileTemplate < Resource
+    BASE_URI = '/rest/server-profile-templates'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['type'] ||= 'ServerProfileTemplateV1'
+    end
+
+    # Create ServerProfile using this template
+    # @param [String] name Name of new server profile
+    # @return [ServerProfile] New server profile from template.
+    #   Temporary object only; call .create to actually create resource on OneView.
+    def new_profile(name = nil)
+      ensure_client && ensure_uri
+      options = @client.rest_get("#{@data['uri']}/new-profile")
+      profile = OneviewSDK::ServerProfile.new(@client, options)
+      profile[:name] = name if name && name.size > 0
+      profile
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module OneviewSDK
+  # Storage pool resource implementation
+  class StoragePool < Resource
+    BASE_URI = '/rest/storage-pools'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values:
+      @data['type'] ||= 'StoragePoolV2'
+    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
+
+    # Set storage system
+    # @param [StorageSystem] storage_system
+    def set_storage_system(storage_system)
+      set('storageSystemUri', storage_system['uri'])
+    end
+
+    def update
+      unavailable_method
+    end
+
+  end
+end

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

@@ -0,0 +1,63 @@
+module OneviewSDK
+  # Storage system resource implementation
+  class StorageSystem < Resource
+    BASE_URI = '/rest/storage-systems'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values:
+      @data['type'] ||= 'StorageSystemV3'
+    end
+
+    def create
+      ensure_client
+      task = @client.rest_post(self.class::BASE_URI, { 'body' => self['credentials'] }, @api_version)
+      temp = @data.clone
+      task = @client.wait_for(task['uri'] || task['location'])
+      @data['uri'] = task['associatedResource']['resourceUri']
+      refresh
+      temp.delete('credentials')
+      update(temp)
+      self
+    end
+
+    def retrieve!
+      if @data['name']
+        super
+      else
+        ip_hostname = self['credentials'][:ip_hostname] || self['credentials']['ip_hostname']
+        results = self.class.find_by(@client, credentials: { ip_hostname: ip_hostname })
+        return false unless results.size == 1
+        set_all(results[0].data)
+        true
+      end
+    end
+
+    # Get host types for storage system resource
+    # @param [Client] client client handle REST calls to OV instance
+    # @return [String] response body
+    def self.get_host_types(client)
+      response = client.rest_get(BASE_URI + '/host-types')
+      response.body
+    end
+
+    # List of storage pools
+    def get_storage_pools
+      response = @client.rest_get(@data['uri'] + '/storage-pools')
+      response.body
+    end
+
+    # List of all managed target ports for the specified storage system
+    # or only the one specified
+    # @param [String] port Target port
+    def get_managed_ports(port = nil)
+      response = if port.nil?
+                   @client.rest_get("#{@data['uri']}/managedPorts")
+                 else
+                   @client.rest_get("#{@data['uri']}/managedPorts/#{port}")
+                 end
+      response.body
+    end
+
+  end
+end

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

@@ -0,0 +1,119 @@
+module OneviewSDK
+  # Uplink set resource implementation
+  class UplinkSet < Resource
+    BASE_URI = '/rest/uplink-sets'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['fcNetworkUris'] ||= []
+      @data['fcoeNetworkUris'] ||= []
+      @data['networkUris'] ||= []
+      @data['portConfigInfos'] ||= []
+      @data['primaryPortLocation'] = nil
+      @data['type'] ||= 'uplink-setV3'
+    end
+
+    # @!group Validates
+
+    VALID_ETHERNET_NETWORK_TYPES = %w(NotApplicable Tagged Tunnel Unknown Untagged).freeze
+    # Validate ethernetNetworkType
+    # @param [String] value NotApplicable, Tagged, Tunnel, Unknown, Untagged
+    def validate_ethernetNetworkType(value)
+      fail 'Invalid ethernet network type' unless VALID_ETHERNET_NETWORK_TYPES.include?(value)
+    end
+
+    VALID_LACP_TIMERS = %w(Short Long).freeze
+    # Validate lacpTimer
+    # @param [String] value Short, Long
+    def validate_lacpTimer(value)
+      return if value.to_s.empty?
+      fail 'Invalid lacp timer' unless %w(Short Long).include?(value)
+    end
+
+    VALID_MANUAL_LOGIN_REDISTRIBUTION_STATES = %w(Distributed Distributing DistributionFailed NotSupported Supported).freeze
+    # Validate manualLoginRedistributionState
+    # @param [String] value Distributed, Distributing, DistributionFailed, NotSupported, Supported
+    def validate_manualLoginRedistributionState(value)
+      fail 'Invalid manual login redistribution state' unless VALID_MANUAL_LOGIN_REDISTRIBUTION_STATES.include?(value)
+    end
+
+    VALID_NETWORK_TYPES = %w(Ethernet FibreChannel).freeze
+    # Validate networkType
+    # @param [String] value Ethernet, FibreChannel
+    def validate_networkType(value)
+      fail 'Invalid network type' unless VALID_NETWORK_TYPES.include?(value)
+    end
+
+    VALID_LOCATION_ENTRIES_TYPES = %w(Bay Enclosure Ip Password Port StackingDomainId StackingMemberId UserId).freeze
+    # Validate locationEntriesType
+    # @param [String] value Bay Enclosure Ip Password Port StackingDomainId StackingMemberId UserId
+    def validate_locationEntriesType(value)
+      fail 'Invalid location entry type' unless VALID_LOCATION_ENTRIES_TYPES.include?(value)
+    end
+
+    VALID_REACHABILITIES = ['NotReachable', 'Reachable', 'RedundantlyReachable', 'Unknown', nil].freeze
+    # Validate ethernetNetworkType request
+    # @param [String] value NotReachable Reachable RedundantlyReachable Unknown
+    def validate_reachability(value)
+      fail 'Invalid reachability' unless VALID_REACHABILITIES.include?(value)
+    end
+
+    VALID_STATUSES = %w(OK Disabled Warning Critical Unknown).freeze
+    # Validate ethernetNetworkType request
+    # @param [String] value OK Disabled Warning Critical Unknown
+    def validate_status(value)
+      fail 'Invalid status' unless VALID_STATUSES.include?(value)
+    end
+
+    # @!endgroup
+
+    # Add portConfigInfos to the array
+    # @param [String] portUri
+    # @param [String] speed
+    # @param [Hash] locationEntries
+    def add_port_config(portUri, speed, locationEntries)
+      entry = {
+        'portUri' => portUri,
+        'desiredSpeed' => speed,
+        'location' => {
+          'locationEntries' => locationEntries
+        }
+      }
+      @data['portConfigInfos'] << entry
+    end
+
+    # Set logical interconnect uri
+    # @param [OneviewSDK::LogicalInterconnect, Hash] logical_interconnect
+    def set_logical_interconnect(logical_interconnect)
+      uri = logical_interconnect[:uri] || logical_interconnect['uri']
+      fail 'Invalid object' unless uri
+      @data['logicalInterconnectUri'] = uri
+    end
+
+    # Add an uri to networkUris array
+    # @param [OneviewSDK::EthernetNetwork, Hash] network
+    def add_network(network)
+      uri = network[:uri] || network['uri']
+      fail 'Invalid object' unless uri
+      @data['networkUris'].push(uri)
+    end
+
+    # Add an uri to fcnetworkUris array
+    # @param [OneviewSDK::FCNetwork, Hash] network must accept hash syntax
+    def add_fcnetwork(network)
+      uri = network[:uri] || network['uri']
+      fail 'Invalid object' unless uri
+      @data['fcNetworkUris'].push(uri)
+    end
+
+    # Add an uri to fcoenetworkUris array
+    # @param [OneviewSDK::FCoENetwork, Hash] network must accept hash syntax
+    def add_fcoenetwork(network)
+      uri = network[:uri] || network['uri']
+      fail 'Invalid object' unless uri
+      @data['fcoeNetworkUris'].push(uri)
+    end
+
+  end
+end