Use host and port for rest server from the environment, fallback to localhost and default port

On node creation:
 - set the proper node+domain for the node object
 - set the node name to the short name
 - set the fqdn and domain name to the proper ones
 - set the uptime to avoid failure on node details UI
 - set the roles to just names so they are linked to the barclamps
 - set the product name, serial number so they are shown properly in the UI
 - set the disk key for removable so disks are shown properly on the UI
 - count all the memory and aggregate it to be shown on the UI
 - count the processors with an 0 index so they can be shown in the UI
 - allocate the node
 - set the node to ready status

All the node creation changes also fix the node not being shown properly when going to the details
as well as crowbar crashing when moving the node to a different group

Author: Itxaka

crowbar_framework/app/controllers/intelrsd_controller.rb

@@ -14,22 +14,23 @@
 # limitations under the License.
 #
 
-require 'json'
+require "json"
 
 # An important note on interfacing with Redfish APIS:
 #
-# * Only specific top level URIs may be assumed, and even these 
-#   may be absent based on the implementation. (for ex: there 
-#   might be no /redfish/v1/Systems collection on something that
-#   doesn't have compute nodes )
-# * The API will eventually be implemented on a system that breaks
-#   any data model and hence the URIs must be dynamically discovered
-# * The data model represented here using @node_object_list prepares
-#   a list of all the available Systems along with the properties 
-#   and IDs of available resources in each system. This data model
-#   needs to be appropriately mapped to the Node object of the system
-#   where the data model is employed.
-# 
+# Only specific top level URIs may be assumed, and even these
+# may be absent based on the implementation. (for ex: there
+# might be no /redfish/v1/Systems collection on something that
+# doesn't have compute nodes )
+#
+# The API will eventually be implemented on a system that breaks
+# any data model and hence the URIs must be dynamically discovered
+# The data model represented here using @node_object_list prepares
+# a list of all the available Systems along with the properties
+# and IDs of available resources in each system. This data model
+# needs to be appropriately mapped to the Node object of the system
+# where the data model is employed.
+#
 
 class RsdController < ApplicationController
   attr_reader :redfish_client, :logger
@@ -48,67 +49,33 @@ def show
     end
   end
 
-  def allocate
-    all_sys_list = get_systems
-    all_sys_list.each do |sys_id|
-      next unless params[sys_id.to_s] == "1"
-      node = get_crowbar_node_object(sys_id)
-      node.allocate
-      node.set_state("ready")
-    end
-    redirect_to rsd_show_path, notice: "Selected nodes allocated as compute nodes"
+  def initialize
+    host = ENV["CROWBAR_REDFISH_HOST"] || "localhost"
+    port = ENV["CROWBAR_REDFISH_PORT"] || "8443"
+    @redfish_client = RedfishHelper::RedfishClient.new(host, port)
+    @node_object_list = []
   end
 
   def get_system_resource_list(sys_id, resource)
     resource_list = []
     items = @redfish_client.get_resource("Systems/#{sys_id}/#{resource}")
-    items["Members"].each do | item |
+    items["Members"].each do |item|
       item_odata_id = item["@odata.id"]
-      item_id = item_odata_id.split(/\//)[-1]
+      item_id = item_odata_id.split("/")[-1]
       resource_item = @redfish_client.get_resource("Systems/#{sys_id}/#{resource}/#{item_id}")
       resource_list.push(resource_item)
     end
-    return resource_list
+    resource_list
   end
 
   def make_node_object_for_system(sys_id)
-    nodeobject = Hash.new()
+    nodeobject = Hash.new
     nodeobject["System_Id"] = sys_id
-    ["Processors", "Memory", "MemoryChunks", 
-     "EthernetInterfaces", "Adapters"].each do | resource |
-      nodeobject["#{resource}"] = get_system_resource_list(sys_id, resource)
-    end
-    return nodeobject
-  end
-
-  def get_processors(sys_id)
-    proc_list = get_system_resource_list(sys_id, "Processors")
-    processors = []
-    proc_list.each do |proc|
-      proc_object = Hash.new
-      proc_object["Model"] = proc["Model"]
-      proc_object["Manufacturer"] = proc["Manufacturer"]
-      proc_object["Architecture"] = proc["Architecture"]
-      proc_object["TotalCores"] = proc["TotalCores"]
-      proc_object["TotalThreads"] = proc["TotalThreads"]
-      processors.push(proc_object)
-    end
-    processors
-  end
-
-  def get_memory(sys_id)
-    mem_list = get_system_resource_list(sys_id, "Memory")
-    memories = []
-    mem_list.each do |mem|
-      mem_object = Hash.new
-      mem_object["MemoryType"] = mem["MemoryType"]
-      mem_object["CapacityMB"] = mem["CapacityMiB"]
-      mem_object["Speed"] = mem["OperatingSpeedMHz"]
-      mem_object["Size"] = mem["SizeMiB"]
-      mem_object["Health"] = mem["Health"]
-      memories.push(mem_object)
+    ["Processors", "Memory", "MemoryChunks",
+     "EthernetInterfaces", "Adapters"].each do |resource|
+      nodeobject[resource.to_s] = get_system_resource_list(sys_id, resource)
     end
-    memories
+    nodeobject
   end
 
   def get_systems
@@ -117,75 +84,70 @@ def get_systems
 
     @systems["Members"].each do |member|
       odata_id = member["@odata.id"]
-      sys_id = odata_id.split(/\//)[-1]
+      sys_id = odata_id.split("/")[-1]
       sys_list.push(sys_id)
     end
-    return sys_list
+    sys_list
   end
 
   def get_system_data(sys_id)
     system_data = @redfish_client.get_resource("Systems/#{sys_id}")
     system_object = make_node_object_for_system(sys_id)
     ["Processors", "Memory", "MemoryChunks",
-     "EthernetInterfaces", "Adapters"].each do | resource |
-      system_data["#{resource}"] = system_object["#{resource}"]
+     "EthernetInterfaces", "Adapters"].each do |resource|
+      system_data[resource.to_s] = system_object[resource.to_s]
     end
-    return system_data
+    system_data
   end
 
-  def get_all_systems
-    sys_list = get_systems
-    all_systems = []
-    sys_list.each do |sys_id|
-      sys_object = Hash.new
-      sys_object["SystemId"] = sys_id
-      sys_object["Processors"] = get_processors(sys_id)
-      sys_object["Memory"] = get_memory(sys_id)
-      all_systems.push(sys_object)
+  def get_rsd_nodes
+    system_list = get_systems
+    system_list.each do |system|
+      node_object = make_node_object_for_system(system)
+      @node_object_list.push(node_object)
     end
-    all_systems
+    @node_object_list
+  end
+
+  def reset_system(sys_id)
+    post_action("Systems/#{sys_id}", action: "ComputerSystem.Reset")
   end
 
   def get_crowbar_node_object(sys_id)
     system_object = get_system_data(sys_id)
     node_name_prefix = "d"
-    node_name_prefix = "IRSD-" if system_object["Oem"].key?("Intel_RackScale")
+    node_name_prefix = "IRSD" if system_object["Oem"].key?("Intel_RackScale")
 
     # Pickin up the first IP address. This may not be always the correct address.
     # It must be revisited when testing with Rackscale hardware.
     eth_interface = system_object["EthernetInterfaces"].first
-    node_name = node_name_prefix + eth_interface["MACAddress"].tr(":", "-") + "-#{sys_id}"
+    node_name = node_name_prefix + eth_interface["MACAddress"].tr(":", "-")
 
     node = NodeObject.create_new "#{node_name}.#{Crowbar::Settings.domain}".downcase
 
     node.set["name"] = node_name
-    # set a flag to identify this node as a rackscale one
-    node.set["rackscale"] = true
-    # track the rackscale id for this node
-    node.set["rackscale_id"] = sys_id
-    node.set["target_cpu"] = "x86_64"
+    node.set["target_cpu"] = ""
     node.set["target_vendor"] = "suse"
-    node.set["host_cpu"] = system_object["ProcessorSummary"]["Model"]
+    node.set["host_cpu"] = ""
     node.set["host_vendor"] = "suse"
     node.set["kernel"] = ""   # Kernel modules and configurations
     node.set["counters"] = "" # various network interfaces and other counters
     node.set["hostname"] = node_name
     node.set["fqdn"] = "#{node_name}.#{Crowbar::Settings.domain}"
     node.set["domain"] = Crowbar::Settings.domain
-
     ipaddress_data = eth_interface["IPv4Addresses"].first
-    node.set['ipaddress'] = ipaddress_data["Address"]
-    node.set['macaddress'] = eth_interface["MACAddress"]
+    node.set["ipaddress"] = ipaddress_data["Address"]
+    node.set["macaddress"] = eth_interface["MACAddress"]
     ip6address_data = eth_interface["IPv6Addresses"].first
-    node.set['ip6address'] = ip6address_data["Address"]
-    #node.set['ohai_time'] = ""
-    node.set['recipes'] = ""
+    node.set["ip6address"] = ip6address_data["Address"]
+    node.set["uptime"] = "1 minute"
+    node.set["recipes"] = ""
 
     # Add other roles as seen fit
     node.set["roles"] = []
     ["deployer-config-default", "network-config-default", "dns-config-default",
      "logging-config-default", "ntp-config-default",
-     "provisioner-base", "provisioner-config-default", "nova-compute"].each do |role_name|
+     "provisioner-base", "provisioner-config-default"].each do |role_name|
       node["roles"] << role_name
     end
 
@@ -197,15 +159,25 @@ def get_crowbar_node_object(sys_id)
     node.set["virtualization"]["role"] = "guest"
     node.set["platform"] = "suse"
     node.set["platform_version"] = "12.1"
+    node.set["dmi"]["bios"]["all_records"] = ""
+    node.set["dmi"]["bios"]["vendor"] = ""
     node.set["dmi"]["bios"]["version"] = system_object["BiosVersion"]
+    node.set["dmi"]["bios"]["release_date"] = ""
+    node.set["dmi"]["bios"]["address"] = ""
+    node.set["dmi"]["bios"]["runtime_size"] = ""
+    node.set["dmi"]["bios"]["rom_size"] = ""
+    node.set["dmi"]["bios"]["bios_revision"] = ""
     node.set["dmi"]["system"]["product_name"] = system_object["Model"]
-    node.set["dmi"]["system"]["manufacturer"] = system_object["Manufacturer"]
-    node.set["dmi"]["system"]["serial_number"] = system_object["SerialNumber"]
-    node.set["dmi"]["system"]["uuid"] = system_object["UUID"]
+    node.set["dmi"]["system"]["manufacturer"] = ""
+    node.set["dmi"]["system"]["serial_number"] = "Not Specified"
+    node.set["dmi"]["system"]["uuid"] = ""
     node.set["dmi"]["system"]["wake_up_type"] = "Power Switch"
     node.set["dmi"]["system"]["sku_number"] = "Not Specified"
     node.set["dmi"]["system"]["family"] = "Not Specified"
     node.set["dmi"]["chassis"]["serial_number"] = system_object["SerialNumber"]
+    node.set["dmi"]["chassis"]["all_records"] = ""
+    node.set["dmi"]["chassis"]["manufacturer"] = ""
+    node.set["dmi"]["chassis"]["all_records"] = ""
     node.set["dmi"]["chassis"]["boot_up_state"] = "Safe"
     node.set["dmi"]["chassis"]["power_supply_state"] = "Safe"
     # this is needed so its counted properly for the UI
@@ -229,6 +201,15 @@ def get_crowbar_node_object(sys_id)
 
     node.set["filesystem"]["sysfs"] = ""
     node.save
-    node
+    node.allocate
+    node.set_state("ready")
   end
 end
+
+# run it on a thread to not block the UI at the start
+Thread.new do
+  rsd_controller = IntelRSDController.new
+  node_list = rsd_controller.get_systems
+  first_node = node_list.first
+  rsd_controller.get_crowbar_node_object(first_node)
+end

crowbar_framework/app/helpers/redfish_helper.rb

@@ -14,104 +14,63 @@
 # limitations under the License.
 #
 
-require 'json'
-require 'uri'
-require 'net/http'
-require 'rest-client'
+require "json"
+require "uri"
+require "net/http"
+require "rest-client"
 
 module RedfishHelper
   class RedfishClient
     attr_reader :logger
-  
+
     # Standard JSONRPC Error responses
     INVALID_JSON      = -32700
     INVALID_REQUEST   = -32600
     INVALID_PARAMS    = -32602
     METHOD_NOT_FOUND  = -32601
     INTERNAL_ERROR    = -32603
-  
+
     # RedFish-specific constants
-    REDFISH_VERSION   = "redfish/v1/"
-  
-    def initialize(host, port, insecure=true, client_cert=false)
+    REDFISH_VERSION   = "redfish/v1/".freeze
+
+    def initialize(host, port, insecure = true, client_cert = false)
       @service_uri = "https://#{host}:#{port}/#{REDFISH_VERSION}"
       @verify_ssl = OpenSSL::SSL::VERIFY_NONE if insecure
       @ssl_client_cert = false unless client_cert
     end
-  
+
     def handle_exception(json_rpc_error)
-      logger.error(json_rpc_error[:message])
+      Rails.logger.error(json_rpc_error[:message])
     end
-  
+
     def post_action(resource, action:None, params: None)
       uri = @service_uri + resource
       uri += "/Actions/#{action}" if action
-  
+
       begin
         response = RestClient::Request.execute(url: uri,
-                                             method: :post,
-                                             verify_ssl: @verify_ssl,
-                                             ssl_client_cert: @ssl_client_cert)
+                                               method: :post,
+                                               verify_ssl: @verify_ssl,
+                                               ssl_client_cert: @ssl_client_cert)
       rescue
         handle_exception(response)
       end
-      return JSON.parse(response)
+      JSON.parse(response)
     end
-  
+
     def get_resource(resource)
       uri = @service_uri + resource
-      p "QUERYING RESOURCE: #{uri}"
-  
+      Rails.logger.debug("QUERYING RESOURCE: #{uri}")
+
       begin
-        response = RestClient::Request.execute(url: uri, 
-                                         method: :get, 
-                                         verify_ssl: @verify_ssl, 
-                                         ssl_client_cert: @ssl_client_cert)
+        response = RestClient::Request.execute(url: uri,
+                                               method: :get,
+                                               verify_ssl: @verify_ssl,
+                                               ssl_client_cert: @ssl_client_cert)
       rescue
         handle_exception(response)
       end
-  
-      return JSON.parse(response)
+      JSON.parse(response)
     end
   end
 end
-
-# Usage Examples for this client library
-
-# Create a client object
-redfish_client = RedfishHelper::RedfishClient.new("localhost", "8443")
-
-# Check if the Redfish Service responds ( returns redfish/v1)
-api_resp = redfish_client.get_resource("")
-p api_resp
-
-# Check one of the API responses
-systems = redfish_client.get_resource("Systems")
-p systems
-
-sys_list = []
-
-# Loop to run through all available systems and populate a node-object
-systems["Members"].each do |member|
-  p "MEMBER DATA: #{member}"
-  member_id= member["@odata.id"]
-  p "MEMBER ID: #{member_id}"
-  sys_id = member_id.split(/\//)[-1]
-  p "SYSTEM ID: #{sys_id}"
-  sys_data = Hash.new()
-  sys_data["Systems"] = redfish_client.get_resource("Systems/#{sys_id}")
-  p "SYSTEMS DATA: #{sys_data["Systems"]}"
-  sys_data["Processors"] = redfish_client.get_resource("Systems/#{sys_id}/Processors/1")
-  p "PROCESSORS DATA: #{sys_data["Processors"]}"
-  sys_data["Memory"] = redfish_client.get_resource("Systems/#{sys_id}/Memory/1")
-  p "MEMORY DATA: #{sys_data["Memory"]}"
-  sys_data["MemoryChunks"] = redfish_client.get_resource("Systems/#{sys_id}/MemoryChunks/1")
-  p "MEMORY CHUNKS DATA: #{sys_data["MemoryChunks"]}"
-  sys_data["EthernetInterfaces"] = redfish_client.get_resource("Systems/#{sys_id}/EthernetInterfaces/1")
-  p "ETHERNET DATA: #{sys_data["EthernetInterfaces"]}"
-  sys_data["Adapters"] = redfish_client.get_resource("Systems/#{sys_id}/Adapters/1")
-  p "ADAPTERS DATA: #{sys_data["Adapters"]}"
-  sys_list.push(sys_data)
-end
-
-p "NODE OBJECT From Redfish : #{sys_list}"