oneview-sdk 1.0.0

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

@@ -0,0 +1,87 @@
+module OneviewSDK
+  # Interconnect resource implementation
+  class Interconnect < Resource
+    BASE_URI = '/rest/interconnects'.freeze
+    TYPE_URI = '/rest/interconnect-types'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+    end
+
+    def create
+      unavailable_method
+    end
+
+    def update
+      unavailable_method
+    end
+
+    def delete
+      unavailable_method
+    end
+
+    # Retrieve interconnect types
+    # @param [Client] client http client
+    def self.get_types(client)
+      response = client.rest_get(TYPE_URI)
+      response = client.response_handler(response)
+      response['members']
+    end
+
+    # Retrieve interconnect ype with name
+    # @param [Client] client http client
+    # @param [String] name Interconnect type name
+    # @return [Array] Interconnect type
+    def self.get_type(client, name)
+      results = get_types(client)
+      results.find { |interconnect_type| interconnect_type['name'] == name }
+    end
+
+    # Retrieve named servers for this interconnect
+    def name_servers
+      response = @client.rest_get(@data['uri'] + '/nameServers')
+      response.body
+    end
+
+    # Updates an interconnect port
+    # @param [String] portName port name
+    # @param [Hash] attributes hash with attributes and values to be changed
+    def update_port(portName, attributes)
+      @data['ports'].each do |port|
+        next unless port['name'] == portName
+        attributes.each { |key, value| port[key.to_s] = value }
+        response = @client.rest_put(@data['uri'] + '/ports', 'body' => port)
+        @client.response_handler(response)
+      end
+    end
+
+    # Get statistics for an interconnect, for the specified port or subport
+    # @param [String] portName port to retrieve statistics
+    # @param [String] subportNumber subport to retrieve statistics
+    def statistics(portName = nil, subportNumber = nil)
+      uri = if subportNumber.nil?
+              "#{@data['uri']}/statistics/#{portName}"
+            else
+              "#{@data['uri']}/statistics/#{portName}/subport/#{subportNumber}"
+            end
+      response = @client.rest_get(uri)
+      response.body
+    end
+
+    # Triggers a reset of port protection
+    def reset_port_protection
+      response = @client.rest_put(@data['uri'] + '/resetportprotection')
+      @client.response_handler(response)
+    end
+
+    # Update specific attributes of a given interconnect resource
+    # @param [String] operation operation to be performed
+    # @param [String] path path
+    # @param [String] value value
+    def update_attribute(operation, path, value)
+      response = @client.rest_patch(@data['uri'], 'body' => [{ op: operation, path: path, value: value }])
+      @client.response_handler(response)
+    end
+
+  end
+end

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

@@ -0,0 +1,86 @@
+module OneviewSDK
+  # Uplink Sets  resource implementation to be used in Logical interconnect groups
+  class LIGUplinkSet < Resource
+    BASE_URI = '/rest/logical-interconnect-groups'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values:
+      @data['logicalPortConfigInfos'] ||= []
+      @data['lacpTimer'] ||= 'Short'
+      @data['mode'] ||= 'Auto'
+      @data['networkUris'] ||= []
+    end
+
+    # @!group Validates
+
+    VALID_NETWORK_TYPES = %w(FibreChannel Ethernet).freeze
+    # Validate ethernetNetworkType request
+    # @param [String] value FibreChannel, Ethernet
+    def validate_networkType(value)
+      fail 'Invalid network type' unless VALID_NETWORK_TYPES.include?(value)
+      fail 'Attribute missing' if value == 'Ethernet' && !@data['ethernetNetworkType']
+      fail 'Attribute not supported' if value == 'FibreChannel' && @data['ethernetNetworkType']
+    end
+
+    VALID_ETHERNET_NETWORK_TYPES = %w(NotApplicable Tagged Tunnel Unknown Untagged).freeze
+    # Validate ethernetNetworkType request
+    # @param [String] value Notapplicable, Tagged, Tunnel, Unknown, Untagged. Must exist if networkType is 'Ethernet', otherwise shouldn't.
+    def validate_ethernetNetworkType(value)
+      fail 'Invalid ethernetNetworkType' unless VALID_ETHERNET_NETWORK_TYPES.include?(value)
+    end
+
+    # @!endgroup
+
+    # Add existing network to the network list.
+    # Ethernet and FibreChannel networks are allowed.
+    # @param [OneviewSDK::Resource] network resource to be added to the list
+    def add_network(network)
+      fail 'Resource not retrieved from server' unless network['uri']
+      @data['networkUris'] << network['uri']
+    end
+
+    # Specify one uplink passing the VC Bay and the port to be attached.
+    # @param [Fixnum] bay number to identify the VC
+    # @param [String] port to attach the uplink. Allowed D1..D16 and X1..X10
+    def add_uplink(bay, port)
+      entry = {
+        'desiredSpeed' => 'Auto',
+        'logicalLocation' => {
+          'locationEntries' => [
+            { 'relativeValue' => bay, 'type' => 'Bay' },
+            { 'relativeValue' => 1, 'type' => 'Enclosure' },
+            { 'relativeValue' => relative_value_of(port), 'type' => 'Port' }
+          ]
+        }
+      }
+      @data['logicalPortConfigInfos'] << entry
+    end
+
+    # Set all params
+    # @overload sets networkType first
+    def set_all(params = {})
+      params = params.data if params.class <= Resource
+      params = Hash[params.map { |(k, v)| [k.to_s, v] }]
+      network_type = params.delete('networkType')
+      params.each { |key, value| set(key.to_s, value) }
+      set('networkType', network_type) if network_type
+    end
+
+    private
+
+    # Relative values:
+    #   Downlink Ports: D1 is 1, D2 is 2, ....,D15 is 15, D16 is 16;
+    #   Uplink Ports: X1 is 17, X2 is 18, ....,X9 is 25, X10 is 26.
+    def relative_value_of(port)
+      identifier = port.slice!(0)
+      offset = case identifier
+               when 'D' then 0
+               when 'X' then 16
+               else fail "Port not supported: #{identifier} type not found"
+               end
+      port.to_i + offset
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+module OneviewSDK
+  # Logical enclosure resource implementation
+  class LogicalEnclosure < Resource
+    BASE_URI = '/rest/logical-enclosures'.freeze
+
+    def initialize(client, params = {}, api_ver = nil)
+      super
+      # Default values
+      @data['type'] ||= 'LogicalEnclosure'
+    end
+
+    # @!group Validates
+
+    VALID_FABRIC_TYPES = %w(DirectAttach FabricAttach).freeze
+    # Validate fabricType
+    # @param [String] value DirectAttach, FabricAttach
+    # @raise [RuntimeError] if value is not 'DirectAttach' or 'FabricAttach'
+    def validate_fabricType(value)
+      fail 'Invalid fabric type' unless VALID_FABRIC_TYPES.include?(value)
+    end
+
+    # @!endgroup
+
+    # Reapplies the appliance's configuration on enclosures
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the uri is not set
+    # @raise [RuntimeError] if the reapply fails
+    # @return [LogicalEnclosure] self
+    def reconfigure
+      ensure_client && ensure_uri
+      response = @client.rest_put("#{@data['uri']}/configuration", {}, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+    # Makes this logical enclosure consistent with the enclosure group
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the uri is not set
+    # @raise [RuntimeError] if the process fails
+    # @return [Resource] self
+    def update_from_group
+      ensure_client && ensure_uri
+      response = @client.rest_put("#{@data['uri']}/updateFromGroup", {}, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+    # Get the configuration script
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the uri is not set
+    # @raise [RuntimeError] if retrieving fails
+    # @return [String] script
+    def get_script
+      ensure_client && ensure_uri
+      response = @client.rest_get("#{@data['uri']}/script", @api_version)
+      response.body
+    end
+
+    # Updates the configuration script for the logical enclosure
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the uri is not set
+    # @raise [RuntimeError] if the reapply fails
+    # @return [Resource] self
+    def set_script(script)
+      ensure_client && ensure_uri
+      response = @client.rest_put("#{@data['uri']}/script", { 'body' => script }, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+    # Generates a support dump for the logical enclosure
+    # @raise [RuntimeError] if the client is not set
+    # @raise [RuntimeError] if the uri is not set
+    # @raise [RuntimeError] if the process fails when generating the support dump
+    # @return [Resource] self
+    def support_dump(options)
+      ensure_client && ensure_uri
+      response = @client.rest_post("#{@data['uri']}/support-dumps", { 'body' => options }, @api_version)
+      @client.wait_for(response.header['location'])
+      self
+    end
+
+  end
+end

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

@@ -0,0 +1,283 @@
+module OneviewSDK
+  # Logical interconnect resource implementation
+  class LogicalInterconnect < Resource
+    BASE_URI = '/rest/logical-interconnects'.freeze
+    LOCATION_URI = '/rest/logical-interconnects/locations/interconnects'.freeze
+
+    # @!group Validates
+
+    # Validate ethernet trap categories
+    VALID_ENET_TRAP_CATEGORIES = %w(Other PortStatus PortThresholds).freeze
+    def validate_enet_trap_categories(enet_trap_categories)
+      enet_trap_categories.uniq!
+      enet_trap_categories.each do |cat|
+        fail "Ethernet Trap Category #{cat} is not one of the allowed values: #{VALID_ENET_TRAP_CATEGORIES}" unless
+        VALID_ENET_TRAP_CATEGORIES.include?(cat)
+      end
+    end
+
+    # Validate fc trap categories
+    VALID_FC_TRAP_CATEGORIES = %w(Other PortStatus).freeze
+    def validate_fc_trap_categories(fc_trap_categories)
+      fc_trap_categories.uniq!
+      fc_trap_categories.each do |cat|
+        fail "FC Trap Category #{cat} is not one of the allowed values: #{VALID_FC_TRAP_CATEGORIES}" unless VALID_FC_TRAP_CATEGORIES.include?(cat)
+      end
+    end
+
+    # Validate vcm trap categories
+    VALID_VCM_TRAP_CATEGORIES = %w(Legacy).freeze
+    def validate_vcm_trap_categories(vcm_trap_categories)
+      vcm_trap_categories.uniq!
+      vcm_trap_categories.each do |cat|
+        fail "VCM Trap Category #{cat} is not one of the allowed values: #{VALID_VCM_TRAP_CATEGORIES}" unless VALID_VCM_TRAP_CATEGORIES.include?(cat)
+      end
+    end
+
+    # Validate trap severities
+    VALID_TRAP_SEVERITIES = %w(Critical Info Major Minor Normal Unknown Warning).freeze
+    def validate_trap_severities(trap_severities)
+      trap_severities.uniq!
+      trap_severities.each do |cat|
+        fail "Trap Severities #{cat} is not one of the allowed values: #{VALID_TRAP_SEVERITIES}" unless VALID_TRAP_SEVERITIES.include?(cat)
+      end
+    end
+
+    # Validate snmp trap format
+    VALID_TRAP_FORMATS = %w(SNMPv1 SNMPv2 SNMPv3).freeze
+    def validate_trap_format(trap_format)
+      fail "Trap Format #{trap_format} is not one of the allowed values: #{VALID_TRAP_FORMATS}" unless VALID_TRAP_FORMATS.include?(trap_format)
+    end
+
+    # @!endgroup
+
+    # Create an Interconnect in the desired Bay in a specified enclosure
+    # WARN: It does not create the LOGICAL INTERCONNECT itself.
+    # It will fail if no interconnect is already present on the specified position
+    # @param [Fixnum] bay_number Number of the bay to put the interconnect
+    # @param [OneviewSDK::Resource] enclosure Enclosure to insert the interconnect
+    def create(bay_number, enclosure)
+      enclosure.ensure_uri
+      entry = {
+        'locationEntries' => [
+          { 'value' => bay_number, 'type' => 'Bay' },
+          { 'value' => enclosure['uri'], 'type' => 'Enclosure' }
+        ]
+      }
+      response = @client.rest_post(self.class::LOCATION_URI, { 'body' => entry }, @api_version)
+      @client.response_handler(response)
+    end
+
+    # Deletes an INTERCONNECT
+    # WARN: This won't delete the LOGICAL INTERCONNECT itself, and may cause inconsistency between the enclosure and LIG
+    # @param [Fixnum] bay_number Number of the bay to locate the logical interconnect
+    # @param [OneviewSDK::Resource] enclosure Enclosure to remove the logical interconnect
+    def delete(bay_number, enclosure)
+      enclosure.ensure_uri
+      delete_uri = self.class::LOCATION_URI + "?location=Enclosure:#{enclosure['uri']},Bay:#{bay_number}"
+      response = @client.rest_delete(delete_uri, {}, @api_version)
+      @client.response_handler(response)
+      self
+    end
+
+    # Updates internal networks on the logical interconnect
+    # @param [OneviewSDK::EthernetNetworks] networks List of networks to update the Logical Interconnect
+    def update_internal_networks(*networks)
+      uris = []
+      return @client.response_handler(@client.rest_put(@data['uri'] + '/internalNetworks', 'body' => [])) unless networks
+      networks.each do |net|
+        net.retrieve! unless net['uri']
+        uris.push(net['uri'])
+      end
+      response = @client.rest_put(@data['uri'] + '/internalNetworks', 'body' => uris)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Lists internal networks on the logical interconnect
+    # @return [OneviewSDK::Resource] List of networks
+    def list_vlan_networks
+      ensure_client && ensure_uri
+      results = OneviewSDK::Resource.find_by(@client, {}, @data['uri'] + '/internalVlans')
+      internal_networks = []
+      results.each do |vlan|
+        net = if vlan['generalNetworkUri'].include? 'ethernet-network'
+                OneviewSDK::EthernetNetwork.new(@client, uri: vlan['generalNetworkUri'])
+              elsif vlan['generalNetworkUri'].include? 'fc-network'
+                OneviewSDK::FCNetwork.new(@client, uri: vlan['generalNetworkUri'])
+              else
+                OneviewSDK::FCoENetwork.new(@client, uri: vlan['generalNetworkUri'])
+              end
+        net.retrieve!
+        internal_networks.push(net)
+      end
+      internal_networks
+    end
+
+    # Updates ethernet settings of the Logical Interconnect
+    # @note The attribute is defined inside the instance of the Logical Interconnect
+    # @return Updated instance of the Logical Interconnect
+    def update_ethernet_settings
+      ensure_client && ensure_uri
+      fail 'Please retrieve the Logical Interconnect before trying to update' unless @data['ethernetSettings']
+      update_options = {
+        'If-Match' =>  @data['ethernetSettings'].delete('eTag'),
+        'body' => @data['ethernetSettings']
+      }
+      response = @client.rest_put(@data['uri'] + '/ethernetSettings', update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Updates settings of the Logical Interconnect
+    # @param options Options to update the Logical Interconnect
+    # @return Updated instance of the Logical Interconnect
+    def update_settings(options = {})
+      ensure_client && ensure_uri
+      options['type'] ||= 'InterconnectSettingsV3'
+      options['ethernetSettings'] ||= {}
+      options['ethernetSettings']['type'] ||= 'EthernetInterconnectSettingsV3'
+      update_options = {
+        'If-Match' =>  @data['eTag'],
+        'body' => options
+      }
+      response = @client.rest_put(@data['uri'] + '/settings', update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Returns logical interconnects to a consistent state.
+    # The current logical interconnect state is compared to the associated logical interconnect group.
+    # @return returns the updated object
+    def compliance
+      ensure_client && ensure_uri
+      response = @client.rest_put(@data['uri'] + '/compliance', {}, @api_version)
+      body = client.response_handler(response)
+      set_all(body)
+    end
+
+    # Asynchronously applies or re-applies the logical interconnect configuration to all managed interconnects
+    # @return returns the updated object
+    def configuration
+      ensure_client && ensure_uri
+      response = @client.rest_put(@data['uri'] + '/configuration', {}, @api_version)
+      body = client.response_handler(response)
+      set_all(body)
+    end
+
+    # Updates port monitor settings of the Logical Interconnect
+    # @note The attribute is defined inside the instance of the Logical Interconnect
+    # @return Updated instance of the Logical Interconnect
+    def update_port_monitor
+      fail 'Please retrieve the Logical Interconnect before trying to update' unless @data['portMonitor']
+      update_options = {
+        'If-Match' =>  @data['portMonitor'].delete('eTag'),
+        'body' => @data['portMonitor']
+      }
+      response = @client.rest_put(@data['portMonitor']['uri'], update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Updates QoS aggregated configuration of the Logical Interconnect
+    # @note The attribute is defined inside the instance of the Logical Interconnect
+    # @return Updated instance of the Logical Interconnect
+    def update_qos_configuration
+      fail 'Please retrieve the Logical Interconnect before trying to update' unless @data['qosConfiguration']
+      update_options = {
+        'If-Match' =>  @data['qosConfiguration'].delete('eTag'),
+        'body' => @data['qosConfiguration']
+      }
+      response = @client.rest_put(@data['uri'] + '/qos-aggregated-configuration', update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Updates telemetry configuration of the Logical Interconnect
+    # @note The attribute is defined inside the instance of the Logical Interconnect
+    # @return Updated instance of the Logical Interconnect
+    def update_telemetry_configuration
+      fail 'Please retrieve the Logical Interconnect before trying to update' unless @data['telemetryConfiguration']
+      update_options = {
+        'If-Match' =>  @data['telemetryConfiguration'].delete('eTag'),
+        'body' => @data['telemetryConfiguration']
+      }
+      response = @client.rest_put(@data['telemetryConfiguration']['uri'], update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # Updates snmp configuration of the Logical Interconnect
+    # @note The attribute is defined inside the instance of the Logical Interconnect.
+    #   Use helper methods to add the trap destination values: #add_snmp_trap_destination and #generate_trap_options
+    # @return Updated instance of the Logical Interconnect
+    def update_snmp_configuration
+      fail 'Please retrieve the Logical Interconnect before trying to update' unless @data['snmpConfiguration']
+      update_options = {
+        'If-Match' =>  @data['snmpConfiguration'].delete('eTag'),
+        'body' => @data['snmpConfiguration']
+      }
+      response = @client.rest_put(@data['uri'] + '/snmp-configuration', update_options, @api_version)
+      body = @client.response_handler(response)
+      set_all(body)
+    end
+
+    # It will add one trap destination to the Logical Interconnect SNMP configuration
+    # @param trap_format [String] SNMP version for this trap destination, `'SNMPv1'` or `'SNMPv2'` or `'SNMPv3'`
+    # @param trap_destination [String] The trap destination IP address or host name
+    # @param community_string [String] Authentication string for the trap destination
+    # @param trap_options [Hash] Hash with the options of the trap. Create it using generate_trap_options method
+    def add_snmp_trap_destination(trap_destination, trap_format = 'SNMPv1', community_string = 'public', trap_options = {})
+      validate_trap_format(trap_format)
+      trap_options['communityString'] = community_string
+      trap_options['trapDestination'] = trap_destination
+      trap_options['trapFormat'] = trap_format
+      @data['snmpConfiguration']['trapDestinations'].push(trap_options)
+    end
+
+    # Generates trap options to be used in add_snmp_trap_destination method
+    # @param enet_trap_categories [Array]  Filter the traps for this trap destination by the list of configured Ethernet traps
+    #   can contain, `'Other'` or `'PortStatus'` or `'PortThresholds'`
+    # @param fc_trap_categories [Array]  Filter the traps for this trap destination by the list of configured Fibre Channel traps
+    #   can contain, `'Other'` or `'PortStatus'`
+    # @param vcm_trap_categories [Array]  Filter the traps for this trap destination by the list of configured VCM trap, `'Legacy'`
+    # @param trap_severities [Array]  Filter the traps for this trap destination by the list of configured severities
+    #   can contain, `'Critical'` or `'Info'` or `'Major'` or `'Minor'` or `'Normal'` or `'Unknown'` or `'Warning'`
+    # @return [Hash] Contains all trap options for one SNMP destination
+    def generate_trap_options(enet_trap_categories = [], fc_trap_categories = [], vcm_trap_categories = [], trap_severities = [])
+      validate_enet_trap_categories(enet_trap_categories)
+      validate_fc_trap_categories(fc_trap_categories)
+      validate_vcm_trap_categories(vcm_trap_categories)
+      validate_trap_severities(trap_severities)
+      options = {
+        'enetTrapCategories' => enet_trap_categories,
+        'vcmTrapCategories' => vcm_trap_categories,
+        'fcTrapCategories' => fc_trap_categories,
+        'trapSeverities' => trap_severities
+      }
+      options
+    end
+
+    # Gets the installed firmware for a logical interconnect.
+    # @return [Hash] Contains all firmware information
+    def get_firmware
+      ensure_client && ensure_uri
+      response = @client.rest_get(@data['uri'] + '/firmware')
+      @client.response_handler(response)
+    end
+
+    def firmware_update(command, firmware_driver, firmware_options)
+      ensure_client && ensure_uri
+      firmware_options['command'] = command
+      firmware_options['sppUri'] =  firmware_driver['uri']
+      firmware_options['sppName'] = firmware_driver['name']
+      update_json = {
+        'If-Match' => '*',
+        'body' => firmware_options
+      }
+      response = @client.rest_put(@data['uri'] + '/firmware', update_json)
+      @client.response_handler(response)
+    end
+
+  end
+end