hsm_client

package

v0.4.0 Latest Latest Go to latest Published: Dec 12, 2023 License: MIT Imports: 21 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/Cray-HPE/cani

Links

Open Source Insights

README ¶

Go API client for hsm_client

The Hardware State Manager (HSM) inventories, monitors, and manages hardware, and tracks the logical and dynamic component states, such as roles, NIDs, and other basic metadata needed to provide most common administrative and operational functions. HSM is the single source of truth for the state of the system. It contains the component state and information on Redfish endpoints for communicating with components via Redfish. It also allows administrators to create partitions and groups for other uses. ## Resources ### /State/Components HMS components are created during inventory discovery and provide a higher-level representation of the component, including state, NID, role (i.e. compute/service), subtype, and so on. Unlike ComponentEndpoints, however, they are not strictly linked to the parent RedfishEndpoint, and are not automatically deleted when the RedfishEndpoints are (though they can be deleted via a separate call). This is because these components can also represent abstract components, such as removed components (e.g. which would remain, but have their states changed to "Empty" upon removal). ### /Defaults/NodeMaps This resource allows a mapping file (NodeMaps) to be uploaded that maps node xnames to Node IDs, and optionally, to roles and subroles. These mappings are used when discovering nodes for the first time. These mappings should be uploaded prior to discovery and should contain mappings for each valid node xname in the system, whether populated or not. Nodemap is a JSON file that contains the xname of the node, node ID, and optionally role and subrole. Role can be Compute, Application, Storage, Management etc. The NodeMaps collection can be uploaded to HSM automatically at install time by specifying it as a JSON file. As a result, the endpoints are then automatically discovered by REDS, and inventory discovery is performed by HSM. The desired NID numbers will be set as soon as the nodes are created using the NodeMaps collection. It is recommended that Nodemaps are uploaded at install time before discovery happens. If they are uploaded after discovery, then the node xnames need to be manually updated with the correct NIDs. You can update NIDs for individual components by using PATCH /State/Components/{xname}/NID. ### /Inventory/Hardware This resource shows the hardware inventory of the entire system and contains FRU information in location. All entries are displayed as a flat array. ### /Inventory/HardwareByFRU Every component has FRU information. This resource shows the hardware inventory for all FRUs or for a specific FRU irrespective of the location. This information is constant regardless of where the hardware item is currently in the system. If a HWInventoryByLocation entry is currently populated with a piece of hardware, it will have the corresponding HWInventoryByFRU object embedded. This FRU info can also be looked up by FRU ID regardless of the current location. ### /Inventory/Hardware/Query/{xname} This resource gets you information about a specific component and it's sub-components. The xname can be a component, partition, ALL, or s0. Both ALL and s0 represent the entire system. ### /Inventory/RedfishEndpoints This is a BMC or other Redfish controller that has a Redfish entry point and Redfish service root. It is used to discover the components managed by this endpoint during discovery and handles all Redfish interactions by these subcomponents. If the endpoint has been discovered, this entry will include the ComponentEndpoint entries for these managed subcomponents. You can also create a Redfish Endpoint or update the definition for a Redfish Endpoint. The xname identifies the location of all components in the system, including chassis, controllers, nodes, and so on. Redfish endpoints are given to State Manager. ### /Inventory/ComponentEndpoints Component Endpoints are the specific URLs for each individual component that are under the Redfish endpoint. Component endpoints are discovered during inventory discovery. They are the management-plane representation of system components and are linked to the parent Redfish Endpoint. They provide a glue layer to bridge the higher-level representation of a component with how it is represented locally by Redfish. The collection of ComponentEndpoints can be obtained in full, optionally filtered on certain criteria (e.g. obtain just Node components), or accessed by their xname IDs individually. ### /Inventory/ServiceEndpoints ServiceEndpoints help you do things on Redfish like updating the firmware. They are discovered during inventory discovery. ### /groups Groups are named sets of system components, most commonly nodes. A group groups components under an administratively chosen label (group name). Each component may belong to any number of groups. If a group has exclusiveGroup= set, then a node may only be a member of one group that matches that exclusive label. For example, if the exclusive group label 'colors' is associated with groups 'blue', 'red', and 'green', then a component that is part of 'green' could not also be placed in 'red'. You can create, modify, or delete a group and its members. You can also use group names as filters for API calls. ### /partitions A partition is a formal, non-overlapping division of the system that forms an administratively distinct sub-system. Each component may belong to at most one partition. Partitions are used as an access control mechanism or for implementing multi-tenancy. You can create, modify, or delete a partition and its members. You can also use partitions as filters for other API calls. ### /memberships A membership shows the association of a component xname to its set of group labels and partition names. There can be many group labels and up to one partition per component. Memberships are not modified directly, as the underlying group or partition is modified instead. A component can be removed from one of the listed groups or partitions or added via POST as well as being present in the initial set of members when a partition or group is created. You can retrieve the memberships for components or memberships for a specific xname. ### /Inventory/DiscoveryStatus Check discovery status for all components or you can track the status for a specific job ID. You can also check per-endpoint discover status for each RedfishEndpoint. Contains status information about the discovery operation for clients to query. The discover operation returns a link or links to status objects so that a client can determine when the discovery operation is complete. ### /Inventory/Discover Discover subcomponents by querying all RedfishEndpoints. Once the RedfishEndpoint objects are created, inventory discovery will query these controllers and create or update management plane and managed plane objects representing the components (e.g. nodes, node enclosures, node cards for Mountain chassis CMM endpoints). ### /Subscriptions/SCN Manage subscriptions to state change notifications (SCNs) from HSM. You can also subscribe to state change notifications by using the HMS Notification Fanout Daemon API. ## Workflows ### Add and Delete a Redfish Endpoint #### POST /Inventory/RedfishEndpoints When you manually create Redfish endpoints, the discovery is automatically initiated. You would create Redfish endpoints for components that are not automatically discovered by REDS or MEDS. #### GET /Inventory/RedfishEndpoints Check the Redfish endpoints that have been added and check the status of discovery. #### DELETE /Inventory/RedfishEndpoints/{xname} Delete a specific Redfish endpoint. ### Perform Inventory Discovery #### POST /Inventory/Discover Start inventory discovery of a system's subcomponents by querying all Redfish endpoints. If needed, specify an ID or hostname (xname) in the payload. #### GET /Inventory/DiscoveryStatus Check the discovery status of all Redfish endpoints. You can also check the discovery status for each individual component by providing ID. ### Query and Update HMS Components (State/NID) #### GET /State/Components Retrieve all HMS Components found by inventory discovery as a named ("Components") array. #### PATCH /State/Components/{xname}/Enabled Modify the component's Enabled field. #### DELETE /State/Components/{xname} Delete a specific HMS component by providing its xname. As noted, components are not automatically deleted when RedfishEndpoints or ComponentEndpoints are deleted. ### Create and Delete a New Group #### GET /hsm/v2/State/Components Retrieve a list of desired components and their state. Select the nodes that you want to group. #### POST /groups Create the new group with desired members. Provide a group label (required), description, name, members etc. in the JSON payload. #### GET /groups/{group_label} Retrieve the group that was create with the label. #### GET /State/Components/{group_label} Retrieve the current state for all the components in the group. #### DELETE /groups/{group_label} Delete the group specified by {group_label}. ## Valid State Transitions Prior State -> New State - Reason Ready -> Standby - HBTD if node has many missed heartbeats Ready -> Ready/Warning - HBTD if node has a few missed heartbeats Standby -> Ready - HBTD Node re-starts heartbeating On -> Ready - HBTD Node started heartbeating Off -> Ready - HBTD sees heartbeats before Redfish Event (On) Standby -> On - Redfish Event (On) or if re-discovered while in the standby state Off -> On - Redfish Event (On) Standby -> Off - Redfish Event (Off) Ready -> Off - Redfish Event (Off) On -> Off - Redfish Event (Off) Any State -> Empty - Redfish Endpoint is disabled meaning component removal Generally, nodes transition 'Off' -> 'On' -> 'Ready' when going from 'Off' to booted, and 'Ready' -> 'Ready/Warning' -> 'Standby' -> 'Off' when shutdown.

Overview

This API client was generated by the swagger-codegen project. By using the swagger-spec from a remote server, you can easily generate an API client.

API version: 1.0.0
Package version: 1.0.0
Build package: io.swagger.codegen.v3.generators.go.GoClientCodegen

Installation

Put the package under your project folder and add the following in import:

import "./hsm_client"

Documentation for API Endpoints

All URIs are relative to https://sms/apis/smd/hsm/v2

Class	Method	HTTP request	Description
AdminLocksApi	LocksDisablePost	Post /locks/disable	Disables the ability to create a reservation on components.
AdminLocksApi	LocksLockPost	Post /locks/lock	Locks components.
AdminLocksApi	LocksRepairPost	Post /locks/repair	Repair components lock and reservation ability.
AdminLocksApi	LocksStatusGet	Get /locks/status	Retrieve lock status for all components or a filtered subset of components.
AdminLocksApi	LocksStatusPost	Post /locks/status	Retrieve lock status for component IDs.
AdminLocksApi	LocksUnlockPost	Post /locks/unlock	Unlocks components.
AdminReservationsApi	LocksReservationsPost	Post /locks/reservations	Create reservations
AdminReservationsApi	LocksReservationsReleasePost	Post /locks/reservations/release	Releases existing reservations.
AdminReservationsApi	LocksReservationsRemovePost	Post /locks/reservations/remove	Forcibly deletes existing reservations.
CliDangerThisWillDeleteAllComponentEndpointsContinueApi	DoComponentEndpointsDeleteAll	Delete /Inventory/ComponentEndpoints	Delete all ComponentEndpoints
CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApi	DoCompEthInterfaceDeleteAllV2	Delete /Inventory/EthernetInterfaces	Clear the component Ethernet interface collection.
CliDangerThisWillDeleteAllComponentsInHSMContinueApi	DoComponentsDeleteAll	Delete /State/Components	Delete all components
CliDangerThisWillDeleteAllFRUsForHSMContinueApi	DoHWInvByFRUDeleteAll	Delete /Inventory/HardwareByFRU	Delete all HWInventoryByFRU entries
CliDangerThisWillDeleteAllHardwareHistoryContinueApi	DoHWInvHistByLocationDeleteAll	Delete /Inventory/Hardware/History	Clear the HWInventory history.
CliDangerThisWillDeleteAllHardwareInventoryContinueApi	DoHWInvByLocationDeleteAll	Delete /Inventory/Hardware	Delete all HWInventoryByLocation entries
CliDangerThisWillDeleteAllHistoryForThisFRUContinueApi	DoHWInvHistByFRUDelete	Delete /Inventory/HardwareByFRU/History/{fruid}	Delete history for the HWInventoryByFRU entry with FRU identifier {fruid}
CliDangerThisWillDeleteAllHistoryForThisXnameContinueApi	DoHWInvHistByLocationDelete	Delete /Inventory/Hardware/History/{xname}	DELETE history for the HWInventoryByLocation entry with ID (location) {xname}
CliDangerThisWillDeleteAllNodeMapsContinueApi	DoNodeMapsDeleteAll	Delete /Defaults/NodeMaps	Delete all NodeMap entities
CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApi	DoRedfishEndpointsDeleteAll	Delete /Inventory/RedfishEndpoints	Delete all RedfishEndpoints
CliDangerThisWillDeleteAllServiceEndpointsContinueApi	DoServiceEndpointsDeleteAll	Delete /Inventory/ServiceEndpoints	Delete all ServiceEndpoints
CliIgnoreApi	DoDeleteSCNSubscription	Delete /Subscriptions/SCN/{id}	Delete a state change notification subscription
CliIgnoreApi	DoDeleteSCNSubscriptionsAll	Delete /Subscriptions/SCN	Delete all state change notification subscriptions
CliIgnoreApi	DoGetSCNSubscription	Get /Subscriptions/SCN/{id}	Retrieve a currently-held state change notification subscription
CliIgnoreApi	DoGetSCNSubscriptionsAll	Get /Subscriptions/SCN	Retrieve currently-held state change notification subscriptions
CliIgnoreApi	DoHWInvByLocationPost	Post /Inventory/Hardware	Create/Update hardware inventory entries
CliIgnoreApi	DoPatchSCNSubscription	Patch /Subscriptions/SCN/{id}	Update a subscription for state change notifications
CliIgnoreApi	DoPostSCNSubscription	Post /Subscriptions/SCN	Create a subscription for state change notifications
CliIgnoreApi	DoPowerMapsDeleteAll	Delete /sysinfo/powermaps	Delete all PowerMap entities
CliIgnoreApi	DoPutSCNSubscription	Put /Subscriptions/SCN/{id}	Update a subscription for state change notifications
CliIgnoreApi	DoRedfishEndpointPut	Put /Inventory/RedfishEndpoints/{xname}	Update definition for RedfishEndpoint ID {xname}
CliIgnoreApi	LocksReservationsPost	Post /locks/reservations	Create reservations
CliIgnoreApi	LocksReservationsReleasePost	Post /locks/reservations/release	Releases existing reservations.
CliIgnoreApi	LocksReservationsRemovePost	Post /locks/reservations/remove	Forcibly deletes existing reservations.
CliIgnoreApi	LocksServiceReservationsCheckPost	Post /locks/service/reservations/check	Check the validity of reservations.
CliIgnoreApi	LocksServiceReservationsPost	Post /locks/service/reservations	Create reservations
CliIgnoreApi	LocksServiceReservationsReleasePost	Post /locks/service/reservations/release	Releases existing reservations.
CliIgnoreApi	LocksServiceReservationsRenewPost	Post /locks/service/reservations/renew	Renew existing reservations.
ComponentApi	DoCompArrayNIDPatch	Patch /State/Components/BulkNID	Update multiple components' NIDs via ComponentArray
ComponentApi	DoCompBulkEnabledPatch	Patch /State/Components/BulkEnabled	Update multiple components' Enabled values via a list of xnames
ComponentApi	DoCompBulkFlagOnlyPatch	Patch /State/Components/BulkFlagOnly	Update multiple components' Flag values via a list of xnames
ComponentApi	DoCompBulkRolePatch	Patch /State/Components/BulkRole	Update multiple components' Role values via a list of xnames
ComponentApi	DoCompBulkStateDataPatch	Patch /State/Components/BulkStateData	Update multiple components' state data via a list of xnames
ComponentApi	DoCompBulkSwStatusPatch	Patch /State/Components/BulkSoftwareStatus	Update multiple components' SoftwareStatus values via a list of xnames
ComponentApi	DoCompEnabledPatch	Patch /State/Components/{xname}/Enabled	Update component Enabled value at {xname}
ComponentApi	DoCompFlagOnlyPatch	Patch /State/Components/{xname}/FlagOnly	Update component Flag value at {xname}
ComponentApi	DoCompNIDPatch	Patch /State/Components/{xname}/NID	Update component NID value at {xname}
ComponentApi	DoCompRolePatch	Patch /State/Components/{xname}/Role	Update component Role and SubRole values at {xname}
ComponentApi	DoCompStatePatch	Patch /State/Components/{xname}/StateData	Update component state data at {xname}
ComponentApi	DoCompSwStatusPatch	Patch /State/Components/{xname}/SoftwareStatus	Update component SoftwareStatus value at {xname}
ComponentApi	DoComponentByNIDGet	Get /State/Components/ByNID/{nid}	Retrieve component with NID={nid}
ComponentApi	DoComponentByNIDQueryPost	Post /State/Components/ByNID/Query	Create component query (by NID ranges), returning ComponentArray
ComponentApi	DoComponentDelete	Delete /State/Components/{xname}	Delete component with ID {xname}
ComponentApi	DoComponentGet	Get /State/Components/{xname}	Retrieve component at {xname}
ComponentApi	DoComponentPut	Put /State/Components/{xname}	Create/Update an HMS Component
ComponentApi	DoComponentQueryGet	Get /State/Components/Query/{xname}	Retrieve component query for {xname}, returning ComponentArray
ComponentApi	DoComponentsDeleteAll	Delete /State/Components	Delete all components
ComponentApi	DoComponentsGet	Get /State/Components	Retrieve collection of HMS Components
ComponentApi	DoComponentsPost	Post /State/Components	Create/Update a collection of HMS Components
ComponentApi	DoComponentsQueryPost	Post /State/Components/Query	Create component query (by xname list), returning ComponentArray
ComponentEndpointApi	DoComponentEndpointDelete	Delete /Inventory/ComponentEndpoints/{xname}	Delete ComponentEndpoint with ID {xname}
ComponentEndpointApi	DoComponentEndpointGet	Get /Inventory/ComponentEndpoints/{xname}	Retrieve ComponentEndpoint at {xname}
ComponentEndpointApi	DoComponentEndpointsDeleteAll	Delete /Inventory/ComponentEndpoints	Delete all ComponentEndpoints
ComponentEndpointApi	DoComponentEndpointsGet	Get /Inventory/ComponentEndpoints	Retrieve ComponentEndpoints Collection
ComponentEthernetInterfacesApi	DoCompEthInterfaceDeleteAllV2	Delete /Inventory/EthernetInterfaces	Clear the component Ethernet interface collection.
ComponentEthernetInterfacesApi	DoCompEthInterfaceDeleteV2	Delete /Inventory/EthernetInterfaces/{ethInterfaceID}	DELETE existing component Ethernet interface with {ethInterfaceID}
ComponentEthernetInterfacesApi	DoCompEthInterfaceGetV2	Get /Inventory/EthernetInterfaces/{ethInterfaceID}	GET existing component Ethernet interface {ethInterfaceID}
ComponentEthernetInterfacesApi	DoCompEthInterfaceIPAddressDeleteV2	Delete /Inventory/EthernetInterfaces/{ethInterfaceID}/IPAddresses/{ipAddress}	DELETE existing IP address mapping with {ipAddress} from a component Ethernet interface with {ethInterfaceID}
ComponentEthernetInterfacesApi	DoCompEthInterfaceIPAddressPatchV2	Patch /Inventory/EthernetInterfaces/{ethInterfaceID}/IPAddresses/{ipAddress}	UPDATE metadata for existing IP address {ipAddress} in a component Ethernet interface {ethInterfaceID
ComponentEthernetInterfacesApi	DoCompEthInterfaceIPAddressesGetV2	Get /Inventory/EthernetInterfaces/{ethInterfaceID}/IPAddresses	Retrieve all IP addresses of a component Ethernet interface {ethInterfaceID}
ComponentEthernetInterfacesApi	DoCompEthInterfaceIPAddressesPostV2	Post /Inventory/EthernetInterfaces/{ethInterfaceID}/IPAddresses	CREATE a new IP address mapping in a component Ethernet interface (via POST)
ComponentEthernetInterfacesApi	DoCompEthInterfacePatchV2	Patch /Inventory/EthernetInterfaces/{ethInterfaceID}	UPDATE metadata for existing component Ethernet interface {ethInterfaceID}
ComponentEthernetInterfacesApi	DoCompEthInterfacePostV2	Post /Inventory/EthernetInterfaces	CREATE a new component Ethernet interface (via POST)
ComponentEthernetInterfacesApi	DoCompEthInterfacesGetV2	Get /Inventory/EthernetInterfaces	GET ALL existing component Ethernet interfaces
DiscoverApi	DoInventoryDiscoverPost	Post /Inventory/Discover	Create Discover operation request
DiscoveryStatusApi	DoDiscoveryStatusGet	Get /Inventory/DiscoveryStatus/{id}	Retrieve DiscoveryStatus entry matching {id}
DiscoveryStatusApi	DoDiscoveryStatusGetAll	Get /Inventory/DiscoveryStatus	Retrieve all DiscoveryStatus entries in collection
GroupApi	DoGroupDelete	Delete /groups/{group_label}	Delete existing group with {group_label}
GroupApi	DoGroupGet	Get /groups/{group_label}	Retrieve existing group {group_label}
GroupApi	DoGroupLabelsGet	Get /groups/labels	Retrieve all existing group labels
GroupApi	DoGroupMemberDelete	Delete /groups/{group_label}/members/{xname_id}	Delete member from existing group
GroupApi	DoGroupMembersGet	Get /groups/{group_label}/members	Retrieve all members of existing group
GroupApi	DoGroupMembersPost	Post /groups/{group_label}/members	Create new member of existing group (via POST)
GroupApi	DoGroupPatch	Patch /groups/{group_label}	Update metadata for existing group {group_label}
GroupApi	DoGroupsGet	Get /groups	Retrieve all existing groups
GroupApi	DoGroupsPost	Post /groups	Create a new group
HWInventoryApi	DoHWInvByLocationQueryGet	Get /Inventory/Hardware/Query/{xname}	Retrieve results of HWInventory query starting at {xname}
HWInventoryByFRUApi	DoHWInvByFRUDelete	Delete /Inventory/HardwareByFRU/{fruid}	Delete HWInventoryByFRU entry with FRU identifier {fruid}
HWInventoryByFRUApi	DoHWInvByFRUDeleteAll	Delete /Inventory/HardwareByFRU	Delete all HWInventoryByFRU entries
HWInventoryByFRUApi	DoHWInvByFRUGet	Get /Inventory/HardwareByFRU/{fruid}	Retrieve HWInventoryByFRU for {fruid}
HWInventoryByFRUApi	DoHWInvByFRUGetAll	Get /Inventory/HardwareByFRU	Retrieve all HWInventoryByFRU entries in a flat array
HWInventoryByLocationApi	DoHWInvByLocationDelete	Delete /Inventory/Hardware/{xname}	DELETE HWInventoryByLocation entry with ID (location) {xname}
HWInventoryByLocationApi	DoHWInvByLocationDeleteAll	Delete /Inventory/Hardware	Delete all HWInventoryByLocation entries
HWInventoryByLocationApi	DoHWInvByLocationGet	Get /Inventory/Hardware/{xname}	Retrieve HWInventoryByLocation entry at {xname}
HWInventoryByLocationApi	DoHWInvByLocationGetAll	Get /Inventory/Hardware	Retrieve all HWInventoryByLocation entries in array
HWInventoryByLocationApi	DoHWInvByLocationPost	Post /Inventory/Hardware	Create/Update hardware inventory entries
HWInventoryHistoryApi	DoHWInvHistByFRUDelete	Delete /Inventory/HardwareByFRU/History/{fruid}	Delete history for the HWInventoryByFRU entry with FRU identifier {fruid}
HWInventoryHistoryApi	DoHWInvHistByFRUGet	Get /Inventory/HardwareByFRU/History/{fruid}	Retrieve the history entries for the HWInventoryByFRU for {fruid}
HWInventoryHistoryApi	DoHWInvHistByFRUsGet	Get /Inventory/HardwareByFRU/History	Retrieve the history entries for all HWInventoryByFRU entries.
HWInventoryHistoryApi	DoHWInvHistByLocationDelete	Delete /Inventory/Hardware/History/{xname}	DELETE history for the HWInventoryByLocation entry with ID (location) {xname}
HWInventoryHistoryApi	DoHWInvHistByLocationDeleteAll	Delete /Inventory/Hardware/History	Clear the HWInventory history.
HWInventoryHistoryApi	DoHWInvHistByLocationGet	Get /Inventory/Hardware/History/{xname}	Retrieve the history entries for the HWInventoryByLocation entry at {xname}
HWInventoryHistoryApi	DoHWInvHistByLocationsGet	Get /Inventory/Hardware/History	Retrieve the history entries for all HWInventoryByLocation entries
LockingApi	LocksDisablePost	Post /locks/disable	Disables the ability to create a reservation on components.
LockingApi	LocksLockPost	Post /locks/lock	Locks components.
LockingApi	LocksRepairPost	Post /locks/repair	Repair components lock and reservation ability.
LockingApi	LocksReservationsPost	Post /locks/reservations	Create reservations
LockingApi	LocksReservationsReleasePost	Post /locks/reservations/release	Releases existing reservations.
LockingApi	LocksReservationsRemovePost	Post /locks/reservations/remove	Forcibly deletes existing reservations.
LockingApi	LocksServiceReservationsCheckPost	Post /locks/service/reservations/check	Check the validity of reservations.
LockingApi	LocksServiceReservationsPost	Post /locks/service/reservations	Create reservations
LockingApi	LocksServiceReservationsReleasePost	Post /locks/service/reservations/release	Releases existing reservations.
LockingApi	LocksServiceReservationsRenewPost	Post /locks/service/reservations/renew	Renew existing reservations.
LockingApi	LocksStatusGet	Get /locks/status	Retrieve lock status for all components or a filtered subset of components.
LockingApi	LocksStatusPost	Post /locks/status	Retrieve lock status for component IDs.
LockingApi	LocksUnlockPost	Post /locks/unlock	Unlocks components.
MembershipApi	DoMembershipGet	Get /memberships/{xname}	Retrieve membership for component {xname}
MembershipApi	DoMembershipsGet	Get /memberships	Retrieve all memberships for components
NodeMapApi	DoNodeMapDelete	Delete /Defaults/NodeMaps/{xname}	Delete NodeMap with ID {xname}
NodeMapApi	DoNodeMapGet	Get /Defaults/NodeMaps/{xname}	Retrieve NodeMap at {xname}
NodeMapApi	DoNodeMapPost	Post /Defaults/NodeMaps	Create or Modify NodeMaps
NodeMapApi	DoNodeMapPut	Put /Defaults/NodeMaps/{xname}	Update definition for NodeMap ID {xname}
NodeMapApi	DoNodeMapsDeleteAll	Delete /Defaults/NodeMaps	Delete all NodeMap entities
NodeMapApi	DoNodeMapsGet	Get /Defaults/NodeMaps	Retrieve all NodeMaps, returning NodeMapArray
PartitionApi	DoPartitionDelete	Delete /partitions/{partition_name}	Delete existing partition with {partition_name}
PartitionApi	DoPartitionGet	Get /partitions/{partition_name}	Retrieve existing partition {partition_name}
PartitionApi	DoPartitionMemberDelete	Delete /partitions/{partition_name}/members/{xname_id}	Delete member from existing partition
PartitionApi	DoPartitionMembersGet	Get /partitions/{partition_name}/members	Retrieve all members of existing partition
PartitionApi	DoPartitionMembersPost	Post /partitions/{partition_name}/members	Create new member of existing partition (via POST)
PartitionApi	DoPartitionNamesGet	Get /partitions/names	Retrieve all existing partition names
PartitionApi	DoPartitionPatch	Patch /partitions/{partition_name}	Update metadata for existing partition {partition_name}
PartitionApi	DoPartitionsGet	Get /partitions	Retrieve all existing partitions
PartitionApi	DoPartitionsPost	Post /partitions	Create new partition (via POST)
PowerMapApi	DoPowerMapDelete	Delete /sysinfo/powermaps/{xname}	Delete PowerMap with ID {xname}
PowerMapApi	DoPowerMapGet	Get /sysinfo/powermaps/{xname}	Retrieve PowerMap at {xname}
PowerMapApi	DoPowerMapPut	Put /sysinfo/powermaps/{xname}	Update definition for PowerMap ID {xname}
PowerMapApi	DoPowerMapsDeleteAll	Delete /sysinfo/powermaps	Delete all PowerMap entities
PowerMapApi	DoPowerMapsGet	Get /sysinfo/powermaps	Retrieve all PowerMaps, returning PowerMapArray
PowerMapApi	DoPowerMapsPost	Post /sysinfo/powermaps	Create or Modify PowerMaps
RedfishEndpointApi	DoRedfishEndpointDelete	Delete /Inventory/RedfishEndpoints/{xname}	Delete RedfishEndpoint with ID {xname}
RedfishEndpointApi	DoRedfishEndpointGet	Get /Inventory/RedfishEndpoints/{xname}	Retrieve RedfishEndpoint at {xname}
RedfishEndpointApi	DoRedfishEndpointPatch	Patch /Inventory/RedfishEndpoints/{xname}	Update (PATCH) definition for RedfishEndpoint ID {xname}
RedfishEndpointApi	DoRedfishEndpointPut	Put /Inventory/RedfishEndpoints/{xname}	Update definition for RedfishEndpoint ID {xname}
RedfishEndpointApi	DoRedfishEndpointQueryGet	Get /Inventory/RedfishEndpoints/Query/{xname}	Retrieve RedfishEndpoint query for {xname}, returning RedfishEndpointArray
RedfishEndpointApi	DoRedfishEndpointsDeleteAll	Delete /Inventory/RedfishEndpoints	Delete all RedfishEndpoints
RedfishEndpointApi	DoRedfishEndpointsGet	Get /Inventory/RedfishEndpoints	Retrieve all RedfishEndpoints, returning RedfishEndpointArray
RedfishEndpointApi	DoRedfishEndpointsPost	Post /Inventory/RedfishEndpoints	Create RedfishEndpoint(s)
SCNApi	DoDeleteSCNSubscription	Delete /Subscriptions/SCN/{id}	Delete a state change notification subscription
SCNApi	DoDeleteSCNSubscriptionsAll	Delete /Subscriptions/SCN	Delete all state change notification subscriptions
SCNApi	DoGetSCNSubscription	Get /Subscriptions/SCN/{id}	Retrieve a currently-held state change notification subscription
SCNApi	DoGetSCNSubscriptionsAll	Get /Subscriptions/SCN	Retrieve currently-held state change notification subscriptions
SCNApi	DoPatchSCNSubscription	Patch /Subscriptions/SCN/{id}	Update a subscription for state change notifications
SCNApi	DoPostSCNSubscription	Post /Subscriptions/SCN	Create a subscription for state change notifications
SCNApi	DoPutSCNSubscription	Put /Subscriptions/SCN/{id}	Update a subscription for state change notifications
ServiceEndpointApi	DoServiceEndpointDelete	Delete /Inventory/ServiceEndpoints/{service}/RedfishEndpoints/{xname}	Delete the {service} ServiceEndpoint managed by {xname}
ServiceEndpointApi	DoServiceEndpointGet	Get /Inventory/ServiceEndpoints/{service}/RedfishEndpoints/{xname}	Retrieve the ServiceEndpoint of a {service} managed by {xname}
ServiceEndpointApi	DoServiceEndpointsDeleteAll	Delete /Inventory/ServiceEndpoints	Delete all ServiceEndpoints
ServiceEndpointApi	DoServiceEndpointsGet	Get /Inventory/ServiceEndpoints/{service}	Retrieve all ServiceEndpoints of a {service}
ServiceEndpointApi	DoServiceEndpointsGetAll	Get /Inventory/ServiceEndpoints	Retrieve ServiceEndpoints Collection
ServiceInfoApi	DoArchValuesGet	Get /service/values/arch	Retrieve all valid values for use with the 'arch' parameter
ServiceInfoApi	DoClassValuesGet	Get /service/values/class	Retrieve all valid values for use with the 'class' parameter
ServiceInfoApi	DoFlagValuesGet	Get /service/values/flag	Retrieve all valid values for use with the 'flag' parameter
ServiceInfoApi	DoLivenessGet	Get /service/liveness	Kubernetes liveness endpoint to monitor service health
ServiceInfoApi	DoNetTypeValuesGet	Get /service/values/nettype	Retrieve all valid values for use with the 'nettype' parameter
ServiceInfoApi	DoReadyGet	Get /service/ready	Kubernetes readiness endpoint to monitor service health
ServiceInfoApi	DoRoleValuesGet	Get /service/values/role	Retrieve all valid values for use with the 'role' parameter
ServiceInfoApi	DoStateValuesGet	Get /service/values/state	Retrieve all valid values for use with the 'state' parameter
ServiceInfoApi	DoSubRoleValuesGet	Get /service/values/subrole	Retrieve all valid values for use with the 'subrole' parameter
ServiceInfoApi	DoTypeValuesGet	Get /service/values/type	Retrieve all valid values for use with the 'type' parameter
ServiceInfoApi	DoValuesGet	Get /service/values	Retrieve all valid values for use as parameters
ServiceReservationsApi	LocksServiceReservationsCheckPost	Post /locks/service/reservations/check	Check the validity of reservations.
ServiceReservationsApi	LocksServiceReservationsPost	Post /locks/service/reservations	Create reservations
ServiceReservationsApi	LocksServiceReservationsReleasePost	Post /locks/service/reservations/release	Releases existing reservations.
ServiceReservationsApi	LocksServiceReservationsRenewPost	Post /locks/service/reservations/renew	Renew existing reservations.

Documentation For Models

Documentation For Authorization

Endpoints do not require authorization.

Author

Documentation ¶

Overview ¶

* Hardware State Manager API * * The Hardware State Manager (HSM) inventories, monitors, and manages hardware, and tracks the logical and dynamic component states, such as roles, NIDs, and other basic metadata needed to provide most common administrative and operational functions. HSM is the single source of truth for the state of the system. It contains the component state and information on Redfish endpoints for communicating with components via Redfish. It also allows administrators to create partitions and groups for other uses. ## Resources ### /State/Components HMS components are created during inventory discovery and provide a higher-level representation of the component, including state, NID, role (i.e. compute/service), subtype, and so on. Unlike ComponentEndpoints, however, they are not strictly linked to the parent RedfishEndpoint, and are not automatically deleted when the RedfishEndpoints are (though they can be deleted via a separate call). This is because these components can also represent abstract components, such as removed components (e.g. which would remain, but have their states changed to \"Empty\" upon removal). ### /Defaults/NodeMaps This resource allows a mapping file (NodeMaps) to be uploaded that maps node xnames to Node IDs, and optionally, to roles and subroles. These mappings are used when discovering nodes for the first time. These mappings should be uploaded prior to discovery and should contain mappings for each valid node xname in the system, whether populated or not. Nodemap is a JSON file that contains the xname of the node, node ID, and optionally role and subrole. Role can be Compute, Application, Storage, Management etc. The NodeMaps collection can be uploaded to HSM automatically at install time by specifying it as a JSON file. As a result, the endpoints are then automatically discovered by REDS, and inventory discovery is performed by HSM. The desired NID numbers will be set as soon as the nodes are created using the NodeMaps collection. It is recommended that Nodemaps are uploaded at install time before discovery happens. If they are uploaded after discovery, then the node xnames need to be manually updated with the correct NIDs. You can update NIDs for individual components by using PATCH /State/Components/{xname}/NID. ### /Inventory/Hardware This resource shows the hardware inventory of the entire system and contains FRU information in location. All entries are displayed as a flat array. ### /Inventory/HardwareByFRU Every component has FRU information. This resource shows the hardware inventory for all FRUs or for a specific FRU irrespective of the location. This information is constant regardless of where the hardware item is currently in the system. If a HWInventoryByLocation entry is currently populated with a piece of hardware, it will have the corresponding HWInventoryByFRU object embedded. This FRU info can also be looked up by FRU ID regardless of the current location. ### /Inventory/Hardware/Query/{xname} This resource gets you information about a specific component and it's sub-components. The xname can be a component, partition, ALL, or s0. Both ALL and s0 represent the entire system. ### /Inventory/RedfishEndpoints This is a BMC or other Redfish controller that has a Redfish entry point and Redfish service root. It is used to discover the components managed by this endpoint during discovery and handles all Redfish interactions by these subcomponents. If the endpoint has been discovered, this entry will include the ComponentEndpoint entries for these managed subcomponents. You can also create a Redfish Endpoint or update the definition for a Redfish Endpoint. The xname identifies the location of all components in the system, including chassis, controllers, nodes, and so on. Redfish endpoints are given to State Manager. ### /Inventory/ComponentEndpoints Component Endpoints are the specific URLs for each individual component that are under the Redfish endpoint. Component endpoints are discovered during inventory discovery. They are the management-plane representation of system components and are linked to the parent Redfish Endpoint. They provide a glue layer to bridge the higher-level representation of a component with how it is represented locally by Redfish. The collection of ComponentEndpoints can be obtained in full, optionally filtered on certain criteria (e.g. obtain just Node components), or accessed by their xname IDs individually. ### /Inventory/ServiceEndpoints ServiceEndpoints help you do things on Redfish like updating the firmware. They are discovered during inventory discovery. ### /groups Groups are named sets of system components, most commonly nodes. A group groups components under an administratively chosen label (group name). Each component may belong to any number of groups. If a group has exclusiveGroup=<excl-label> set, then a node may only be a member of one group that matches that exclusive label. For example, if the exclusive group label 'colors' is associated with groups 'blue', 'red', and 'green', then a component that is part of 'green' could not also be placed in 'red'. You can create, modify, or delete a group and its members. You can also use group names as filters for API calls. ### /partitions A partition is a formal, non-overlapping division of the system that forms an administratively distinct sub-system. Each component may belong to at most one partition. Partitions are used as an access control mechanism or for implementing multi-tenancy. You can create, modify, or delete a partition and its members. You can also use partitions as filters for other API calls. ### /memberships A membership shows the association of a component xname to its set of group labels and partition names. There can be many group labels and up to one partition per component. Memberships are not modified directly, as the underlying group or partition is modified instead. A component can be removed from one of the listed groups or partitions or added via POST as well as being present in the initial set of members when a partition or group is created. You can retrieve the memberships for components or memberships for a specific xname. ### /Inventory/DiscoveryStatus Check discovery status for all components or you can track the status for a specific job ID. You can also check per-endpoint discover status for each RedfishEndpoint. Contains status information about the discovery operation for clients to query. The discover operation returns a link or links to status objects so that a client can determine when the discovery operation is complete. ### /Inventory/Discover Discover subcomponents by querying all RedfishEndpoints. Once the RedfishEndpoint objects are created, inventory discovery will query these controllers and create or update management plane and managed plane objects representing the components (e.g. nodes, node enclosures, node cards for Mountain chassis CMM endpoints). ### /Subscriptions/SCN Manage subscriptions to state change notifications (SCNs) from HSM. You can also subscribe to state change notifications by using the HMS Notification Fanout Daemon API. ## Workflows ### Add and Delete a Redfish Endpoint #### POST /Inventory/RedfishEndpoints When you manually create Redfish endpoints, the discovery is automatically initiated. You would create Redfish endpoints for components that are not automatically discovered by REDS or MEDS. #### GET /Inventory/RedfishEndpoints Check the Redfish endpoints that have been added and check the status of discovery. #### DELETE /Inventory/RedfishEndpoints/{xname} Delete a specific Redfish endpoint. ### Perform Inventory Discovery #### POST /Inventory/Discover Start inventory discovery of a system's subcomponents by querying all Redfish endpoints. If needed, specify an ID or hostname (xname) in the payload. #### GET /Inventory/DiscoveryStatus Check the discovery status of all Redfish endpoints. You can also check the discovery status for each individual component by providing ID. ### Query and Update HMS Components (State/NID) #### GET /State/Components Retrieve all HMS Components found by inventory discovery as a named (\"Components\") array. #### PATCH /State/Components/{xname}/Enabled Modify the component's Enabled field. #### DELETE /State/Components/{xname} Delete a specific HMS component by providing its xname. As noted, components are not automatically deleted when RedfishEndpoints or ComponentEndpoints are deleted. ### Create and Delete a New Group #### GET /hsm/v2/State/Components Retrieve a list of desired components and their state. Select the nodes that you want to group. #### POST /groups Create the new group with desired members. Provide a group label (required), description, name, members etc. in the JSON payload. #### GET /groups/{group_label} Retrieve the group that was create with the label. #### GET /State/Components/{group_label} Retrieve the current state for all the components in the group. #### DELETE /groups/{group_label} Delete the group specified by {group_label}. ## Valid State Transitions ``` Prior State -> New State - Reason Ready -> Standby - HBTD if node has many missed heartbeats Ready -> Ready/Warning - HBTD if node has a few missed heartbeats Standby -> Ready - HBTD Node re-starts heartbeating On -> Ready - HBTD Node started heartbeating Off -> Ready - HBTD sees heartbeats before Redfish Event (On) Standby -> On - Redfish Event (On) or if re-discovered while in the standby state Off -> On - Redfish Event (On) Standby -> Off - Redfish Event (Off) Ready -> Off - Redfish Event (Off) On -> Off - Redfish Event (Off) Any State -> Empty - Redfish Endpoint is disabled meaning component removal ``` Generally, nodes transition 'Off' -> 'On' -> 'Ready' when going from 'Off' to booted, and 'Ready' -> 'Ready/Warning' -> 'Standby' -> 'Off' when shutdown. * * API version: 1.0.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

Index ¶

Variables
func CacheExpires(r *http.Response) time.Time
type APIClient
- func NewAPIClient(cfg *Configuration) *APIClient
- func (c *APIClient) ChangeBasePath(path string)
type APIKey
type APIResponse
- func NewAPIResponse(r *http.Response) *APIResponse
- func NewAPIResponseWithError(errorMessage string) *APIResponse
type Actions100ChassisActions
type Actions100ChassisActionsChassisReset
type Actions100ComputerSystemActions
type Actions100ComputerSystemActionsComputerSystemReset
type Actions100ManagerActions
type Actions100ManagerActionsManagerReset
type Actions100OutletActions
type Actions100OutletActionsOutletPowerControl
type Actions100OutletActionsOutletResetBreaker
type Actions100OutletActionsOutletResetStatistics
type AdminLock100
type AdminLocksApiLocksStatusGetOpts
type AdminLocksApiService
- func (a *AdminLocksApiService) LocksDisablePost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
- func (a *AdminLocksApiService) LocksLockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
- func (a *AdminLocksApiService) LocksRepairPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
- func (a *AdminLocksApiService) LocksStatusGet(ctx context.Context, localVarOptionals *AdminLocksApiLocksStatusGetOpts) (AdminStatusCheckResponse100, *http.Response, error)
- func (a *AdminLocksApiService) LocksStatusPost(ctx context.Context, body Xnames) (AdminStatusCheckResponse100, *http.Response, error)
- func (a *AdminLocksApiService) LocksUnlockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
type AdminReservationCreate100
type AdminReservationCreateResponse100
type AdminReservationRemove100
type AdminReservationsApiService
- func (a *AdminReservationsApiService) LocksReservationsPost(ctx context.Context, body AdminReservationCreate100) (AdminReservationCreateResponse100, *http.Response, error)
- func (a *AdminReservationsApiService) LocksReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)
- func (a *AdminReservationsApiService) LocksReservationsRemovePost(ctx context.Context, body AdminReservationRemove100) (XnameResponse100, *http.Response, error)
type AdminStatusCheckResponse100
type BasicAuth
type CliDangerThisWillDeleteAllComponentEndpointsContinueApiService
- func (a *CliDangerThisWillDeleteAllComponentEndpointsContinueApiService) DoComponentEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService
- func (a *CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService) DoCompEthInterfaceDeleteAllV2(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllComponentsInHSMContinueApiService
- func (a *CliDangerThisWillDeleteAllComponentsInHSMContinueApiService) DoComponentsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllFRUsForHSMContinueApiService
- func (a *CliDangerThisWillDeleteAllFRUsForHSMContinueApiService) DoHWInvByFRUDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllHardwareHistoryContinueApiService
- func (a *CliDangerThisWillDeleteAllHardwareHistoryContinueApiService) DoHWInvHistByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllHardwareInventoryContinueApiService
- func (a *CliDangerThisWillDeleteAllHardwareInventoryContinueApiService) DoHWInvByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService
- func (a *CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService) DoHWInvHistByFRUDelete(ctx context.Context, fruid string) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService
- func (a *CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService) DoHWInvHistByLocationDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllNodeMapsContinueApiService
- func (a *CliDangerThisWillDeleteAllNodeMapsContinueApiService) DoNodeMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService
- func (a *CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService) DoRedfishEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliDangerThisWillDeleteAllServiceEndpointsContinueApiService
- func (a *CliDangerThisWillDeleteAllServiceEndpointsContinueApiService) DoServiceEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
type CliIgnoreApiService
- func (a *CliIgnoreApiService) DoDeleteSCNSubscription(ctx context.Context, id string) (*http.Response, error)
- func (a *CliIgnoreApiService) DoDeleteSCNSubscriptionsAll(ctx context.Context) (*http.Response, error)
- func (a *CliIgnoreApiService) DoGetSCNSubscription(ctx context.Context, id string) (SubscriptionsScnPostSubscription, *http.Response, error)
- func (a *CliIgnoreApiService) DoGetSCNSubscriptionsAll(ctx context.Context) (SubscriptionsScnSubscriptionArray, *http.Response, error)
- func (a *CliIgnoreApiService) DoHWInvByLocationPost(ctx context.Context, body InventoryHardwareBody) (Response100, *http.Response, error)
- func (a *CliIgnoreApiService) DoPatchSCNSubscription(ctx context.Context, body SubscriptionsScnPatchSubscription, id string) (*http.Response, error)
- func (a *CliIgnoreApiService) DoPostSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription) (SubscriptionsScnSubscriptionArrayItem100, *http.Response, error)
- func (a *CliIgnoreApiService) DoPowerMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *CliIgnoreApiService) DoPutSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription, id string) (*http.Response, error)
- func (a *CliIgnoreApiService) DoRedfishEndpointPut(ctx context.Context, body RedfishEndpoint100RedfishEndpoint, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)
- func (a *CliIgnoreApiService) LocksReservationsPost(ctx context.Context, body AdminReservationCreate100) (AdminReservationCreateResponse100, *http.Response, error)
- func (a *CliIgnoreApiService) LocksReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)
- func (a *CliIgnoreApiService) LocksReservationsRemovePost(ctx context.Context, body AdminReservationRemove100) (XnameResponse100, *http.Response, error)
- func (a *CliIgnoreApiService) LocksServiceReservationsCheckPost(ctx context.Context, body DeputyKeys100) (ServiceReservationCheckResponse100, *http.Response, error)
- func (a *CliIgnoreApiService) LocksServiceReservationsPost(ctx context.Context, body ServiceReservationCreate100) (ServiceReservationCreateResponse100, *http.Response, error)
- func (a *CliIgnoreApiService) LocksServiceReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)
- func (a *CliIgnoreApiService) LocksServiceReservationsRenewPost(ctx context.Context, body ReservedKeysWithRenewal100) (XnameResponse100, *http.Response, error)
type CompEthInterface100
type CompEthInterface100IpAddressMapping
type CompEthInterface100IpAddressMappingPatch
type CompEthInterface100Patch
type Component100Component
type Component100ComponentCreate
type Component100PatchArrayItemNid
type Component100PatchEnabled
type Component100PatchFlagOnly
type Component100PatchNid
type Component100PatchRole
type Component100PatchSoftwareStatus
type Component100PatchStateData
type Component100Put
type Component100ResourceUriCollection
type ComponentApiDoComponentQueryGetOpts
type ComponentApiDoComponentsGetOpts
type ComponentApiService
- func (a *ComponentApiService) DoCompArrayNIDPatch(ctx context.Context, body ComponentArrayPatchArrayNid) (*http.Response, error)
- func (a *ComponentApiService) DoCompBulkEnabledPatch(ctx context.Context, body ComponentArrayPatchArrayEnabled) (*http.Response, error)
- func (a *ComponentApiService) DoCompBulkFlagOnlyPatch(ctx context.Context, body ComponentArrayPatchArrayFlagOnly) (*http.Response, error)
- func (a *ComponentApiService) DoCompBulkRolePatch(ctx context.Context, body ComponentArrayPatchArrayRole) (*http.Response, error)
- func (a *ComponentApiService) DoCompBulkStateDataPatch(ctx context.Context, body ComponentArrayPatchArrayStateData) (*http.Response, error)
- func (a *ComponentApiService) DoCompBulkSwStatusPatch(ctx context.Context, body ComponentArrayPatchArraySoftwareStatus) (*http.Response, error)
- func (a *ComponentApiService) DoCompEnabledPatch(ctx context.Context, body Component100PatchEnabled, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoCompFlagOnlyPatch(ctx context.Context, body Component100PatchFlagOnly, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoCompNIDPatch(ctx context.Context, body Component100PatchNid, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoCompRolePatch(ctx context.Context, body Component100PatchRole, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoCompStatePatch(ctx context.Context, body Component100PatchStateData, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoCompSwStatusPatch(ctx context.Context, body Component100PatchSoftwareStatus, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoComponentByNIDGet(ctx context.Context, nid string) (Component100Component, *http.Response, error)
- func (a *ComponentApiService) DoComponentByNIDQueryPost(ctx context.Context, body ComponentArrayPostByNidQuery) (ComponentArrayComponentArray, *http.Response, error)
- func (a *ComponentApiService) DoComponentDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *ComponentApiService) DoComponentGet(ctx context.Context, xname string) (Component100Component, *http.Response, error)
- func (a *ComponentApiService) DoComponentPut(ctx context.Context, body Component100Put, xname string) (*http.Response, error)
- func (a *ComponentApiService) DoComponentQueryGet(ctx context.Context, xname string, ...) (ComponentArrayComponentArray, *http.Response, error)
- func (a *ComponentApiService) DoComponentsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *ComponentApiService) DoComponentsGet(ctx context.Context, localVarOptionals *ComponentApiDoComponentsGetOpts) (ComponentArrayComponentArray, *http.Response, error)
- func (a *ComponentApiService) DoComponentsPost(ctx context.Context, body ComponentArrayPostArray) (*http.Response, error)
- func (a *ComponentApiService) DoComponentsQueryPost(ctx context.Context, body ComponentArrayPostQuery) (ComponentArrayComponentArray, *http.Response, error)
type ComponentArrayComponentArray
type ComponentArrayPatchArrayEnabled
type ComponentArrayPatchArrayFlagOnly
type ComponentArrayPatchArrayNid
type ComponentArrayPatchArrayRole
type ComponentArrayPatchArraySoftwareStatus
type ComponentArrayPatchArrayStateData
type ComponentArrayPostArray
type ComponentArrayPostByNidQuery
type ComponentArrayPostQuery
type ComponentByNid100ResourceUriCollection
type ComponentEndpoint100ComponentEndpoint
type ComponentEndpoint100RedfishChassisInfo
type ComponentEndpoint100RedfishManagerInfo
type ComponentEndpoint100RedfishOutletInfo
type ComponentEndpoint100RedfishPowerDistributionInfo
type ComponentEndpoint100RedfishSystemInfo
type ComponentEndpoint100ResourceUriCollection
type ComponentEndpointApiDoComponentEndpointsGetOpts
type ComponentEndpointApiService
- func (a *ComponentEndpointApiService) DoComponentEndpointDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *ComponentEndpointApiService) DoComponentEndpointGet(ctx context.Context, xname string) (ComponentEndpoint100ComponentEndpoint, *http.Response, error)
- func (a *ComponentEndpointApiService) DoComponentEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *ComponentEndpointApiService) DoComponentEndpointsGet(ctx context.Context, ...) (ComponentEndpointArrayComponentEndpointArray, *http.Response, error)
type ComponentEndpointArrayComponentEndpointArray
type ComponentEndpointArrayPostQuery
type ComponentEndpointChassis
type ComponentEndpointComputerSystem
type ComponentEndpointManager
type ComponentEndpointOutlet
type ComponentEndpointPowerDistribution
type ComponentEthernetInterfacesApiDoCompEthInterfacesGetV2Opts
type ComponentEthernetInterfacesApiService
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceDeleteAllV2(ctx context.Context) (Response100, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceDeleteV2(ctx context.Context, ethInterfaceID string) (Response100, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceGetV2(ctx context.Context, ethInterfaceID string) (CompEthInterface100, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressDeleteV2(ctx context.Context, ethInterfaceID string, ipAddress string) (Response100, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressPatchV2(ctx context.Context, body CompEthInterface100IpAddressMappingPatch, ...) (*http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressesGetV2(ctx context.Context, ethInterfaceID string) ([]CompEthInterface100IpAddressMapping, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressesPostV2(ctx context.Context, body CompEthInterface100IpAddressMapping, ...) (ResourceUri100, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfacePatchV2(ctx context.Context, body CompEthInterface100Patch, ethInterfaceID string) (*http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfacePostV2(ctx context.Context, body CompEthInterface100) (ResourceUri100, *http.Response, error)
- func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfacesGetV2(ctx context.Context, ...) ([]CompEthInterface100, *http.Response, error)
type ComponentStatus100
type Configuration
- func NewConfiguration() *Configuration
- func (c *Configuration) AddDefaultHeader(key string, value string)
type Counts100
type DeputyKeys100
type Discover100DiscoverInput
type DiscoverApiDoInventoryDiscoverPostOpts
type DiscoverApiService
- func (a *DiscoverApiService) DoInventoryDiscoverPost(ctx context.Context, localVarOptionals *DiscoverApiDoInventoryDiscoverPostOpts) ([]ResourceUri100, *http.Response, error)
type DiscoveryStatus100Details
type DiscoveryStatus100DiscoveryStatus
type DiscoveryStatusApiService
- func (a *DiscoveryStatusApiService) DoDiscoveryStatusGet(ctx context.Context, id float64) (DiscoveryStatus100DiscoveryStatus, *http.Response, error)
- func (a *DiscoveryStatusApiService) DoDiscoveryStatusGetAll(ctx context.Context) ([]DiscoveryStatus100DiscoveryStatus, *http.Response, error)
type EthernetNicInfo100
type FailedXnames100
type GenericSwaggerError
- func (e GenericSwaggerError) Body() []byte
- func (e GenericSwaggerError) Error() string
- func (e GenericSwaggerError) Model() interface{}
type Group100
type Group100Patch
type GroupApiDoGroupGetOpts
type GroupApiDoGroupMembersGetOpts
type GroupApiDoGroupsGetOpts
type GroupApiService
- func (a *GroupApiService) DoGroupDelete(ctx context.Context, groupLabel string) (Response100, *http.Response, error)
- func (a *GroupApiService) DoGroupGet(ctx context.Context, groupLabel string, ...) (Group100, *http.Response, error)
- func (a *GroupApiService) DoGroupLabelsGet(ctx context.Context) ([]string, *http.Response, error)
- func (a *GroupApiService) DoGroupMemberDelete(ctx context.Context, groupLabel string, xnameId string) (Response100, *http.Response, error)
- func (a *GroupApiService) DoGroupMembersGet(ctx context.Context, groupLabel string, ...) (Members100, *http.Response, error)
- func (a *GroupApiService) DoGroupMembersPost(ctx context.Context, body MemberId, groupLabel string) ([]ResourceUri100, *http.Response, error)
- func (a *GroupApiService) DoGroupPatch(ctx context.Context, body Group100Patch, groupLabel string) (*http.Response, error)
- func (a *GroupApiService) DoGroupsGet(ctx context.Context, localVarOptionals *GroupApiDoGroupsGetOpts) ([]Group100, *http.Response, error)
- func (a *GroupApiService) DoGroupsPost(ctx context.Context, body Group100) ([]ResourceUri100, *http.Response, error)
type HWInventoryApiDoHWInvByLocationQueryGetOpts
type HWInventoryApiService
- func (a *HWInventoryApiService) DoHWInvByLocationQueryGet(ctx context.Context, xname string, ...) (HwInventory100HwInventory, *http.Response, error)
type HWInventoryByFRUApiDoHWInvByFRUGetAllOpts
type HWInventoryByFRUApiService
- func (a *HWInventoryByFRUApiService) DoHWInvByFRUDelete(ctx context.Context, fruid string) (Response100, *http.Response, error)
- func (a *HWInventoryByFRUApiService) DoHWInvByFRUDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *HWInventoryByFRUApiService) DoHWInvByFRUGet(ctx context.Context, fruid string) (HwInventory100HwInventoryByFru, *http.Response, error)
- func (a *HWInventoryByFRUApiService) DoHWInvByFRUGetAll(ctx context.Context, ...) ([]HwInventory100HwInventoryByFru, *http.Response, error)
type HWInventoryByLocationApiDoHWInvByLocationGetAllOpts
type HWInventoryByLocationApiService
- func (a *HWInventoryByLocationApiService) DoHWInvByLocationDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *HWInventoryByLocationApiService) DoHWInvByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *HWInventoryByLocationApiService) DoHWInvByLocationGet(ctx context.Context, xname string) (HwInventory100HwInventoryByLocation, *http.Response, error)
- func (a *HWInventoryByLocationApiService) DoHWInvByLocationGetAll(ctx context.Context, ...) ([]HwInventory100HwInventoryByLocation, *http.Response, error)
- func (a *HWInventoryByLocationApiService) DoHWInvByLocationPost(ctx context.Context, body InventoryHardwareBody) (Response100, *http.Response, error)
type HWInventoryHistoryApiDoHWInvHistByFRUGetOpts
type HWInventoryHistoryApiDoHWInvHistByFRUsGetOpts
type HWInventoryHistoryApiDoHWInvHistByLocationGetOpts
type HWInventoryHistoryApiDoHWInvHistByLocationsGetOpts
type HWInventoryHistoryApiService
- func (a *HWInventoryHistoryApiService) DoHWInvHistByFRUDelete(ctx context.Context, fruid string) (Response100, *http.Response, error)
- func (a *HWInventoryHistoryApiService) DoHWInvHistByFRUGet(ctx context.Context, fruid string, ...) (HwInventory100HwInventoryHistoryArray, *http.Response, error)
- func (a *HWInventoryHistoryApiService) DoHWInvHistByFRUsGet(ctx context.Context, ...) (HwInventory100HwInventoryHistoryCollection, *http.Response, error)
- func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationGet(ctx context.Context, xname string, ...) (HwInventory100HwInventoryHistoryArray, *http.Response, error)
- func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationsGet(ctx context.Context, ...) (HwInventory100HwInventoryHistoryCollection, *http.Response, error)
type HmsArch100
type HmsClass100
type HmsFlag100
type HmsState100
type HmsType100
type HsnInfo100
type HsnInfoEntry100
type HwInvByFruCabinet
type HwInvByFruChassis
type HwInvByFruComputeModule
type HwInvByFruDrive
type HwInvByFruMemory
type HwInvByFruMgmtHlSwitch
type HwInvByFruMgmtSwitch
type HwInvByFruNode
type HwInvByFruNodeAccel
type HwInvByFruNodeAccelRiser
type HwInvByFruNodeBmc
type HwInvByFruNodeEnclosure
type HwInvByFruNodeEnclosurePowerSupply
type HwInvByFruOutlet
type HwInvByFruProcessor
type HwInvByFruRouterBmc
type HwInvByFruRouterModule
type HwInvByFrucduMgmtSwitch
type HwInvByFrucmmRectifier
type HwInvByFruhsnBoard
type HwInvByFruhsnnic
type HwInvByFrupdu
type HwInvByLocCabinet
type HwInvByLocCduMgmtSwitch
type HwInvByLocChassis
type HwInvByLocCmmRectifier
type HwInvByLocComputeModule
type HwInvByLocDrive
type HwInvByLocHsnBoard
type HwInvByLocHsnnic
type HwInvByLocMemory
type HwInvByLocMgmtHlSwitch
type HwInvByLocMgmtSwitch
type HwInvByLocNode
type HwInvByLocNodeAccel
type HwInvByLocNodeAccelRiser
type HwInvByLocNodeBmc
type HwInvByLocNodeEnclosure
type HwInvByLocNodeEnclosurePowerSupply
type HwInvByLocOutlet
type HwInvByLocPdu
type HwInvByLocProcessor
type HwInvByLocRouterBmc
type HwInvByLocRouterModule
type HwInventory100HsnnicLocationInfo
type HwInventory100HsnnicfruInfo
type HwInventory100HwInventory
type HwInventory100HwInventoryByFru
type HwInventory100HwInventoryByLocation
type HwInventory100HwInventoryHistory
type HwInventory100HwInventoryHistoryArray
type HwInventory100HwInventoryHistoryCollection
type HwInventory100RedfishChassisFruInfo
type HwInventory100RedfishChassisLocationInfo
type HwInventory100RedfishCmmRectifierFruInfo
type HwInventory100RedfishCmmRectifierLocationInfo
type HwInventory100RedfishDriveFruInfo
type HwInventory100RedfishDriveLocationInfo
type HwInventory100RedfishManagerFruInfo
type HwInventory100RedfishManagerLocationInfo
type HwInventory100RedfishMemoryFruInfo
type HwInventory100RedfishMemoryLocationInfo
type HwInventory100RedfishMemoryLocationInfoMemoryLocation
type HwInventory100RedfishNodeAccelRiserFruInfo
type HwInventory100RedfishNodeAccelRiserLocationInfo
type HwInventory100RedfishNodeEnclosurePowerSupplyFruInfo
type HwInventory100RedfishNodeEnclosurePowerSupplyLocationInfo
type HwInventory100RedfishOutletFruInfo
type HwInventory100RedfishOutletLocationInfo
type HwInventory100RedfishPduLocationInfo
type HwInventory100RedfishPdufruInfo
type HwInventory100RedfishPdufruInfoCircuitSummary
type HwInventory100RedfishProcessorFruInfo
type HwInventory100RedfishProcessorFruInfoProcessorId
type HwInventory100RedfishProcessorLocationInfo
type HwInventory100RedfishSystemFruInfo
type HwInventory100RedfishSystemLocationInfo
type HwInventory100RedfishSystemLocationInfoMemorySummary
type HwInventory100RedfishSystemLocationInfoProcessorSummary
type InventoryHardwareBody
type Lock100
type Lock100Patch
type LockingApiLocksStatusGetOpts
type LockingApiService
- func (a *LockingApiService) LocksDisablePost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksLockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksRepairPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksReservationsPost(ctx context.Context, body AdminReservationCreate100) (AdminReservationCreateResponse100, *http.Response, error)
- func (a *LockingApiService) LocksReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksReservationsRemovePost(ctx context.Context, body AdminReservationRemove100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksServiceReservationsCheckPost(ctx context.Context, body DeputyKeys100) (ServiceReservationCheckResponse100, *http.Response, error)
- func (a *LockingApiService) LocksServiceReservationsPost(ctx context.Context, body ServiceReservationCreate100) (ServiceReservationCreateResponse100, *http.Response, error)
- func (a *LockingApiService) LocksServiceReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksServiceReservationsRenewPost(ctx context.Context, body ReservedKeysWithRenewal100) (XnameResponse100, *http.Response, error)
- func (a *LockingApiService) LocksStatusGet(ctx context.Context, localVarOptionals *LockingApiLocksStatusGetOpts) (AdminStatusCheckResponse100, *http.Response, error)
- func (a *LockingApiService) LocksStatusPost(ctx context.Context, body Xnames) (AdminStatusCheckResponse100, *http.Response, error)
- func (a *LockingApiService) LocksUnlockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)
type MemberId
type Members100
type Membership100
type MembershipApiDoMembershipsGetOpts
type MembershipApiService
- func (a *MembershipApiService) DoMembershipGet(ctx context.Context, xname string) (Membership100, *http.Response, error)
- func (a *MembershipApiService) DoMembershipsGet(ctx context.Context, localVarOptionals *MembershipApiDoMembershipsGetOpts) ([]Membership100, *http.Response, error)
type Message100ExtendedInfo
type NetType100
type NodeMap100NodeMap
type NodeMap100PostNodeMap
type NodeMapApiService
- func (a *NodeMapApiService) DoNodeMapDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *NodeMapApiService) DoNodeMapGet(ctx context.Context, xname string) (NodeMap100NodeMap, *http.Response, error)
- func (a *NodeMapApiService) DoNodeMapPost(ctx context.Context, body NodeMapArrayNodeMapArray) (Response100, *http.Response, error)
- func (a *NodeMapApiService) DoNodeMapPut(ctx context.Context, body NodeMap100NodeMap, xname string) (NodeMap100PostNodeMap, *http.Response, error)
- func (a *NodeMapApiService) DoNodeMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *NodeMapApiService) DoNodeMapsGet(ctx context.Context) (NodeMapArrayNodeMapArray, *http.Response, error)
type NodeMapArrayNodeMapArray
type Partition100
type Partition100Patch
type PartitionApiDoPartitionsGetOpts
type PartitionApiService
- func (a *PartitionApiService) DoPartitionDelete(ctx context.Context, partitionName string) (Response100, *http.Response, error)
- func (a *PartitionApiService) DoPartitionGet(ctx context.Context, partitionName string) (Partition100, *http.Response, error)
- func (a *PartitionApiService) DoPartitionMemberDelete(ctx context.Context, partitionName string, xnameId string) (Response100, *http.Response, error)
- func (a *PartitionApiService) DoPartitionMembersGet(ctx context.Context, partitionName string) (Members100, *http.Response, error)
- func (a *PartitionApiService) DoPartitionMembersPost(ctx context.Context, body MemberId, partitionName string) ([]ResourceUri100, *http.Response, error)
- func (a *PartitionApiService) DoPartitionNamesGet(ctx context.Context) ([]string, *http.Response, error)
- func (a *PartitionApiService) DoPartitionPatch(ctx context.Context, body Partition100Patch, partitionName string) (*http.Response, error)
- func (a *PartitionApiService) DoPartitionsGet(ctx context.Context, localVarOptionals *PartitionApiDoPartitionsGetOpts) ([]Partition100, *http.Response, error)
- func (a *PartitionApiService) DoPartitionsPost(ctx context.Context, body Partition100) ([]ResourceUri100, *http.Response, error)
type PowerControl100
type PowerControl100Oem
type PowerControl100OemCray
type PowerControl100OemCrayPowerLimit
type PowerControl100RelatedItem
type PowerMap100PostPowerMap
type PowerMap100PowerMap
type PowerMapApiService
- func (a *PowerMapApiService) DoPowerMapDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *PowerMapApiService) DoPowerMapGet(ctx context.Context, xname string) (PowerMap100PowerMap, *http.Response, error)
- func (a *PowerMapApiService) DoPowerMapPut(ctx context.Context, body PowerMap100PowerMap, xname string) (Response100, *http.Response, error)
- func (a *PowerMapApiService) DoPowerMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *PowerMapApiService) DoPowerMapsGet(ctx context.Context) ([]PowerMap100PostPowerMap, *http.Response, error)
- func (a *PowerMapApiService) DoPowerMapsPost(ctx context.Context, body []PowerMap100PostPowerMap) (Response100, *http.Response, error)
type Problem7807
type RedfishEndpoint100RedfishEndpoint
type RedfishEndpoint100RedfishEndpointDiscoveryInfo
type RedfishEndpoint100ResourceUriCollection
type RedfishEndpointApiDoRedfishEndpointsGetOpts
type RedfishEndpointApiService
- func (a *RedfishEndpointApiService) DoRedfishEndpointDelete(ctx context.Context, xname string) (Response100, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointGet(ctx context.Context, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointPatch(ctx context.Context, body RedfishEndpoint100RedfishEndpoint, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointPut(ctx context.Context, body RedfishEndpoint100RedfishEndpoint, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointQueryGet(ctx context.Context, xname string) (RedfishEndpointArrayRedfishEndpointArray, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointsGet(ctx context.Context, ...) (RedfishEndpointArrayRedfishEndpointArray, *http.Response, error)
- func (a *RedfishEndpointApiService) DoRedfishEndpointsPost(ctx context.Context, body RedfishEndpoint100RedfishEndpoint) ([]ResourceUri100, *http.Response, error)
type RedfishEndpointArrayPostQuery
type RedfishEndpointArrayRedfishEndpointArray
type RedfishSubtype100
type RedfishType100
type ReservedKeys100
type ReservedKeysWithRenewal100
type ResourceUri100
type ResourceUriCollectionResourceUriCollection
type Response100
type SCNApiService
- func (a *SCNApiService) DoDeleteSCNSubscription(ctx context.Context, id string) (*http.Response, error)
- func (a *SCNApiService) DoDeleteSCNSubscriptionsAll(ctx context.Context) (*http.Response, error)
- func (a *SCNApiService) DoGetSCNSubscription(ctx context.Context, id string) (SubscriptionsScnPostSubscription, *http.Response, error)
- func (a *SCNApiService) DoGetSCNSubscriptionsAll(ctx context.Context) (SubscriptionsScnSubscriptionArray, *http.Response, error)
- func (a *SCNApiService) DoPatchSCNSubscription(ctx context.Context, body SubscriptionsScnPatchSubscription, id string) (*http.Response, error)
- func (a *SCNApiService) DoPostSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription) (SubscriptionsScnSubscriptionArrayItem100, *http.Response, error)
- func (a *SCNApiService) DoPutSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription, id string) (*http.Response, error)
type ServiceEndpoint100ServiceEndpoint
type ServiceEndpoint100ServiceInfo
type ServiceEndpointApiDoServiceEndpointsGetAllOpts
type ServiceEndpointApiDoServiceEndpointsGetOpts
type ServiceEndpointApiService
- func (a *ServiceEndpointApiService) DoServiceEndpointDelete(ctx context.Context, service string, xname string) (Response100, *http.Response, error)
- func (a *ServiceEndpointApiService) DoServiceEndpointGet(ctx context.Context, service string, xname string) (ServiceEndpoint100ServiceEndpoint, *http.Response, error)
- func (a *ServiceEndpointApiService) DoServiceEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)
- func (a *ServiceEndpointApiService) DoServiceEndpointsGet(ctx context.Context, service string, ...) (ServiceEndpointArrayServiceEndpointArray, *http.Response, error)
- func (a *ServiceEndpointApiService) DoServiceEndpointsGetAll(ctx context.Context, ...) (ServiceEndpointArrayServiceEndpointArray, *http.Response, error)
type ServiceEndpointArrayServiceEndpointArray
type ServiceInfoApiService
- func (a *ServiceInfoApiService) DoArchValuesGet(ctx context.Context) (Values100ArchArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoClassValuesGet(ctx context.Context) (Values100ClassArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoFlagValuesGet(ctx context.Context) (Values100FlagArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoLivenessGet(ctx context.Context) (*http.Response, error)
- func (a *ServiceInfoApiService) DoNetTypeValuesGet(ctx context.Context) (Values100NetTypeArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoReadyGet(ctx context.Context) (Response100, *http.Response, error)
- func (a *ServiceInfoApiService) DoRoleValuesGet(ctx context.Context) (Values100RoleArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoStateValuesGet(ctx context.Context) (Values100StateArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoSubRoleValuesGet(ctx context.Context) (Values100SubRoleArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoTypeValuesGet(ctx context.Context) (Values100TypeArray, *http.Response, error)
- func (a *ServiceInfoApiService) DoValuesGet(ctx context.Context) (Values100Values, *http.Response, error)
type ServiceReservationCheckResponse100
type ServiceReservationCreate100
type ServiceReservationCreateResponse100
type ServiceReservationsApiService
- func (a *ServiceReservationsApiService) LocksServiceReservationsCheckPost(ctx context.Context, body DeputyKeys100) (ServiceReservationCheckResponse100, *http.Response, error)
- func (a *ServiceReservationsApiService) LocksServiceReservationsPost(ctx context.Context, body ServiceReservationCreate100) (ServiceReservationCreateResponse100, *http.Response, error)
- func (a *ServiceReservationsApiService) LocksServiceReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)
- func (a *ServiceReservationsApiService) LocksServiceReservationsRenewPost(ctx context.Context, body ReservedKeysWithRenewal100) (XnameResponse100, *http.Response, error)
type SubscriptionsScnPatchSubscription
type SubscriptionsScnPostSubscription
type SubscriptionsScnSubscriptionArray
type SubscriptionsScnSubscriptionArrayItem100
type Values100ArchArray
type Values100ClassArray
type Values100FlagArray
type Values100NetTypeArray
type Values100RoleArray
type Values100StateArray
type Values100SubRoleArray
type Values100TypeArray
type Values100Values
type XnameKeys100
type XnameKeysDeputyExpire100
type XnameKeysNoExpire100
type XnameResponse100
type XnameWithKey100
type Xnames

Constants ¶

This section is empty.

Variables ¶

View Source

var (
	// ContextOAuth2 takes a oauth2.TokenSource as authentication for the request.
	ContextOAuth2 = contextKey("token")

	// ContextBasicAuth takes BasicAuth as authentication for the request.
	ContextBasicAuth = contextKey("basic")

	// ContextAccessToken takes a string oauth2 access token as authentication for the request.
	ContextAccessToken = contextKey("accesstoken")

	// ContextAPIKey takes an APIKey as authentication for the request
	ContextAPIKey = contextKey("apikey")
)

Functions ¶

func CacheExpires ¶

func CacheExpires(r *http.Response) time.Time

CacheExpires helper function to determine remaining time before repeating a request.

Types ¶

type APIClient ¶

type APIClient struct {
	AdminLocksApi *AdminLocksApiService

	AdminReservationsApi *AdminReservationsApiService

	CliDangerThisWillDeleteAllComponentEndpointsContinueApi *CliDangerThisWillDeleteAllComponentEndpointsContinueApiService

	CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApi *CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService

	CliDangerThisWillDeleteAllComponentsInHSMContinueApi *CliDangerThisWillDeleteAllComponentsInHSMContinueApiService

	CliDangerThisWillDeleteAllFRUsForHSMContinueApi *CliDangerThisWillDeleteAllFRUsForHSMContinueApiService

	CliDangerThisWillDeleteAllHardwareHistoryContinueApi *CliDangerThisWillDeleteAllHardwareHistoryContinueApiService

	CliDangerThisWillDeleteAllHardwareInventoryContinueApi *CliDangerThisWillDeleteAllHardwareInventoryContinueApiService

	CliDangerThisWillDeleteAllHistoryForThisFRUContinueApi *CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService

	CliDangerThisWillDeleteAllHistoryForThisXnameContinueApi *CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService

	CliDangerThisWillDeleteAllNodeMapsContinueApi *CliDangerThisWillDeleteAllNodeMapsContinueApiService

	CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApi *CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService

	CliDangerThisWillDeleteAllServiceEndpointsContinueApi *CliDangerThisWillDeleteAllServiceEndpointsContinueApiService

	CliIgnoreApi *CliIgnoreApiService

	ComponentApi *ComponentApiService

	ComponentEndpointApi *ComponentEndpointApiService

	ComponentEthernetInterfacesApi *ComponentEthernetInterfacesApiService

	DiscoverApi *DiscoverApiService

	DiscoveryStatusApi *DiscoveryStatusApiService

	GroupApi *GroupApiService

	HWInventoryApi *HWInventoryApiService

	HWInventoryByFRUApi *HWInventoryByFRUApiService

	HWInventoryByLocationApi *HWInventoryByLocationApiService

	HWInventoryHistoryApi *HWInventoryHistoryApiService

	LockingApi *LockingApiService

	MembershipApi *MembershipApiService

	NodeMapApi *NodeMapApiService

	PartitionApi *PartitionApiService

	PowerMapApi *PowerMapApiService

	RedfishEndpointApi *RedfishEndpointApiService

	SCNApi *SCNApiService

	ServiceEndpointApi *ServiceEndpointApiService

	ServiceInfoApi *ServiceInfoApiService

	ServiceReservationsApi *ServiceReservationsApiService
	// contains filtered or unexported fields
}

APIClient manages communication with the Hardware State Manager API API v1.0.0 In most cases there should be only one, shared, APIClient.

func NewAPIClient ¶

func NewAPIClient(cfg *Configuration) *APIClient

NewAPIClient creates a new API client. Requires a userAgent string describing your application. optionally a custom http.Client to allow for advanced features such as caching.

func (*APIClient) ChangeBasePath ¶

func (c *APIClient) ChangeBasePath(path string)

Change base path to allow switching to mocks

type APIKey ¶

type APIKey struct {
	Key    string
	Prefix string
}

APIKey provides API key based authentication to a request passed via context using ContextAPIKey

type APIResponse ¶

type APIResponse struct {
	*http.Response `json:"-"`
	Message        string `json:"message,omitempty"`
	// Operation is the name of the swagger operation.
	Operation string `json:"operation,omitempty"`
	// RequestURL is the request URL. This value is always available, even if the
	// embedded *http.Response is nil.
	RequestURL string `json:"url,omitempty"`
	// Method is the HTTP method used for the request.  This value is always
	// available, even if the embedded *http.Response is nil.
	Method string `json:"method,omitempty"`
	// Payload holds the contents of the response body (which may be nil or empty).
	// This is provided here as the raw response.Body() reader will have already
	// been drained.
	Payload []byte `json:"-"`
}

func NewAPIResponse ¶

func NewAPIResponse(r *http.Response) *APIResponse

func NewAPIResponseWithError ¶

func NewAPIResponseWithError(errorMessage string) *APIResponse

type Actions100ChassisActions ¶

type Actions100ChassisActions struct {
	ChassisReset *Actions100ChassisActionsChassisReset `json:"#Chassis.Reset,omitempty"`
}

This is a pass-through field from Redfish that lists the available actions for a Chassis component (if any were found, else if it be omitted entirely).

type Actions100ChassisActionsChassisReset ¶

type Actions100ChassisActionsChassisReset struct {
	// List of allowable 'reset' Redfish Action types
	ResetTypeRedfishAllowableValues []string `json:"ResetType@Redfish.AllowableValues,omitempty"`
	// target URI for Redfish Action
	Target string `json:"target,omitempty"`
}

type Actions100ComputerSystemActions ¶

type Actions100ComputerSystemActions struct {
	ComputerSystemReset *Actions100ComputerSystemActionsComputerSystemReset `json:"#ComputerSystem.Reset,omitempty"`
}

This is a pass-through field from Redfish that lists the available actions for a System component (if any were found, else if it be omitted entirely).

type Actions100ComputerSystemActionsComputerSystemReset ¶

type Actions100ComputerSystemActionsComputerSystemReset struct {
	// List of allowable 'reset' Redfish Action types
	ResetTypeRedfishAllowableValues []string `json:"ResetType@Redfish.AllowableValues,omitempty"`
	// target URI for Redfish Action
	Target string `json:"target,omitempty"`
}

type Actions100ManagerActions ¶

type Actions100ManagerActions struct {
	ManagerReset *Actions100ManagerActionsManagerReset `json:"#Manager.Reset,omitempty"`
}

This is a pass-through field from Redfish that lists the available actions for a Manager component (if any were found, else if it be omitted entirely).

type Actions100ManagerActionsManagerReset ¶

type Actions100ManagerActionsManagerReset struct {
	// List of allowable 'reset' Redfish Action types
	ResetTypeRedfishAllowableValues []string `json:"ResetType@Redfish.AllowableValues,omitempty"`
	// target URI for Redfish Action
	Target string `json:"target,omitempty"`
}

type Actions100OutletActions ¶

type Actions100OutletActions struct {
	OutletPowerControl    *Actions100OutletActionsOutletPowerControl    `json:"#Outlet.PowerControl,omitempty"`
	OutletResetBreaker    *Actions100OutletActionsOutletResetBreaker    `json:"#Outlet.ResetBreaker,omitempty"`
	OutletResetStatistics *Actions100OutletActionsOutletResetStatistics `json:"#Outlet.ResetStatistics,omitempty"`
}

This is a pass-through field from Redfish that lists the available actions for a Outlet component (if any were found, else if it be omitted entirely).

type Actions100OutletActionsOutletPowerControl ¶

type Actions100OutletActionsOutletPowerControl struct {
	// List of allowable PowerControl Redfish Action types
	PowerControlRedfishAllowableValues []string `json:"PowerControl@Redfish.AllowableValues,omitempty"`
	// target URI for Redfish Action
	Target string `json:"target,omitempty"`
}

type Actions100OutletActionsOutletResetBreaker ¶

type Actions100OutletActionsOutletResetBreaker struct {
	// List of allowable ResetBreaker Redfish Action types
	ResetBreakerRedfishAllowableValues []string `json:"ResetBreaker@Redfish.AllowableValues,omitempty"`
	// target URI for Redfish Action
	Target string `json:"target,omitempty"`
}

type Actions100OutletActionsOutletResetStatistics ¶

type Actions100OutletActionsOutletResetStatistics struct {
	// List of allowable ResetStatistics Redfish Action types
	ResetStatisticsRedfishAllowableValues []string `json:"ResetStatistics@Redfish.AllowableValues,omitempty"`
	// target URI for Redfish Action
	Target string `json:"target,omitempty"`
}

type AdminLock100 ¶

type AdminLock100 struct {
	// An array of XName/ID values for the components to query.
	ComponentIDs []string `json:"ComponentIDs,omitempty"`
	// Partition name to filter on, as per current /partitions/names
	Partition []string `json:"Partition,omitempty"`
	// Group label to filter on, as per current /groups/labels
	Group []string `json:"Group,omitempty"`
	// Retrieve all components with the given HMS type.
	Type_ []string `json:"Type,omitempty"`
	// Retrieve all components with the given HMS state.
	State []HmsState100 `json:"State,omitempty"`
	// Retrieve all components with the given HMS flag value.
	Flag []HmsFlag100 `json:"Flag,omitempty"`
	// Retrieve all components with the given enabled status (true or false).
	Enabled []string `json:"Enabled,omitempty"`
	// Retrieve all components with the given software status. Software status is a free form string. Matching is case-insensitive.
	Softwarestatus []string `json:"Softwarestatus,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS role
	Role []string `json:"Role,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS subrole
	Subrole []string `json:"Subrole,omitempty"`
	// Retrieve all components with the given HMS subtype.
	Subtype []string `json:"Subtype,omitempty"`
	// Retrieve all components with the given architecture.
	Arch []HmsArch100 `json:"Arch,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS hardware class. Class can be River, Mountain, etc.
	Class []HmsClass100 `json:"Class,omitempty"`
	// Retrieve all components (i.e. one node) with the given integer NID
	NID []string `json:"NID,omitempty"`
	// Rigid is all or nothing, flexible is best attempt.
	ProcessingModel string `json:"ProcessingModel,omitempty"`
}

type AdminLocksApiLocksStatusGetOpts ¶

type AdminLocksApiLocksStatusGetOpts struct {
	Type_               optional.String
	State               optional.String
	Role                optional.String
	Subrole             optional.String
	Locked              optional.Bool
	Reserved            optional.Bool
	ReservationDisabled optional.Bool
}

type AdminLocksApiService ¶

type AdminLocksApiService service

func (*AdminLocksApiService) LocksDisablePost ¶

func (a *AdminLocksApiService) LocksDisablePost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

AdminLocksApiService Disables the ability to create a reservation on components. Disables the ability to create a reservation on components, deletes any existing reservations. Does not change lock state. Attempting to disable an already-disabled component will not result in an error.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to disable.

@return XnameResponse100

func (*AdminLocksApiService) LocksLockPost ¶

func (a *AdminLocksApiService) LocksLockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

AdminLocksApiService Locks components. Using a component create a lock. Cannot be locked if already locked, or if there is a current reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to lock.

@return XnameResponse100

func (*AdminLocksApiService) LocksRepairPost ¶

func (a *AdminLocksApiService) LocksRepairPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

AdminLocksApiService Repair components lock and reservation ability. Repairs the disabled status of an xname allowing new reservations to be created.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to repair.

@return XnameResponse100

func (*AdminLocksApiService) LocksStatusGet ¶

func (a *AdminLocksApiService) LocksStatusGet(ctx context.Context, localVarOptionals *AdminLocksApiLocksStatusGetOpts) (AdminStatusCheckResponse100, *http.Response, error)

func (*AdminLocksApiService) LocksStatusPost ¶

func (a *AdminLocksApiService) LocksStatusPost(ctx context.Context, body Xnames) (AdminStatusCheckResponse100, *http.Response, error)

AdminLocksApiService Retrieve lock status for component IDs. Using component ID retrieve the status of any lock and/or reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to retrieve status.

@return AdminStatusCheckResponse100

func (*AdminLocksApiService) LocksUnlockPost ¶

func (a *AdminLocksApiService) LocksUnlockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

AdminLocksApiService Unlocks components. Using a component unlock a lock. Cannot be unlocked if already unlocked.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to unlock.

@return XnameResponse100

type AdminReservationCreate100 ¶

type AdminReservationCreate100 struct {
	// An array of XName/ID values for the components to query.
	ComponentIDs []string `json:"ComponentIDs,omitempty"`
	// Partition name to filter on, as per current /partitions/names
	Partition []string `json:"Partition,omitempty"`
	// Group label to filter on, as per current /groups/labels
	Group []string `json:"Group,omitempty"`
	// Retrieve all components with the given HMS type.
	Type_ []string `json:"Type,omitempty"`
	// Retrieve all components with the given HMS state.
	State []HmsState100 `json:"State,omitempty"`
	// Retrieve all components with the given HMS flag value.
	Flag []HmsFlag100 `json:"Flag,omitempty"`
	// Retrieve all components with the given enabled status (true or false).
	Enabled []string `json:"Enabled,omitempty"`
	// Retrieve all components with the given software status. Software status is a free form string. Matching is case-insensitive.
	Softwarestatus []string `json:"Softwarestatus,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS role
	Role []string `json:"Role,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS subrole
	Subrole []string `json:"Subrole,omitempty"`
	// Retrieve all components with the given HMS subtype.
	Subtype []string `json:"Subtype,omitempty"`
	// Retrieve all components with the given architecture.
	Arch []HmsArch100 `json:"Arch,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS hardware class. Class can be River, Mountain, etc.
	Class []HmsClass100 `json:"Class,omitempty"`
	// Retrieve all components (i.e. one node) with the given integer NID
	NID []string `json:"NID,omitempty"`
	// Rigid is all or nothing, flexible is best attempt.
	ProcessingModel string `json:"ProcessingModel,omitempty"`
}

type AdminReservationCreateResponse100 ¶

type AdminReservationCreateResponse100 struct {
	Success []XnameKeysNoExpire100 `json:"Success,omitempty"`
	Failure []FailedXnames100      `json:"Failure,omitempty"`
}

type AdminReservationRemove100 ¶

type AdminReservationRemove100 struct {
	// An array of XName/ID values for the components to query.
	ComponentIDs []string `json:"ComponentIDs,omitempty"`
	// Partition name to filter on, as per current /partitions/names
	Partition []string `json:"Partition,omitempty"`
	// Group label to filter on, as per current /groups/labels
	Group []string `json:"Group,omitempty"`
	// Retrieve all components with the given HMS type.
	Type_ []string `json:"Type,omitempty"`
	// Retrieve all components with the given HMS state.
	State []HmsState100 `json:"State,omitempty"`
	// Retrieve all components with the given HMS flag value.
	Flag []HmsFlag100 `json:"Flag,omitempty"`
	// Retrieve all components with the given enabled status (true or false).
	Enabled []string `json:"Enabled,omitempty"`
	// Retrieve all components with the given software status. Software status is a free form string. Matching is case-insensitive.
	Softwarestatus []string `json:"Softwarestatus,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS role
	Role []string `json:"Role,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS subrole
	Subrole []string `json:"Subrole,omitempty"`
	// Retrieve all components with the given HMS subtype.
	Subtype []string `json:"Subtype,omitempty"`
	// Retrieve all components with the given architecture.
	Arch []HmsArch100 `json:"Arch,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS hardware class. Class can be River, Mountain, etc.
	Class []HmsClass100 `json:"Class,omitempty"`
	// Retrieve all components (i.e. one node) with the given integer NID
	NID []string `json:"NID,omitempty"`
	// Rigid is all or nothing, flexible is best attempt.
	ProcessingModel string `json:"ProcessingModel,omitempty"`
}

type AdminReservationsApiService ¶

type AdminReservationsApiService service

func (*AdminReservationsApiService) LocksReservationsPost ¶

func (a *AdminReservationsApiService) LocksReservationsPost(ctx context.Context, body AdminReservationCreate100) (AdminReservationCreateResponse100, *http.Response, error)

AdminReservationsApiService Create reservations Creates reservations on a set of xnames of infinite duration. Component must be locked to create a reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to create reservations. A `rigid` processing model will result in the entire set of xnames not having reservations created if an xname doesn't exist, or isn't locked, or if already reserved. A `flexible` processing model will perform all actions possible.

@return AdminReservationCreateResponse100

func (*AdminReservationsApiService) LocksReservationsReleasePost ¶

func (a *AdminReservationsApiService) LocksReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)

AdminReservationsApiService Releases existing reservations. Given a list of {xname & reservation key}, releases the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to release reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation released if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*AdminReservationsApiService) LocksReservationsRemovePost ¶

func (a *AdminReservationsApiService) LocksReservationsRemovePost(ctx context.Context, body AdminReservationRemove100) (XnameResponse100, *http.Response, error)

AdminReservationsApiService Forcibly deletes existing reservations. Given a list of components, forcibly deletes any existing reservation. Does not change lock state; does not disable the reservation ability of the component. An empty set of xnames will delete reservations on all xnames. This functionality should be used sparingly, the normal flow should be to release reservations, versus removing them.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to remove reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation removed if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

type AdminStatusCheckResponse100 ¶

type AdminStatusCheckResponse100 struct {
	Components []ComponentStatus100 `json:"Components,omitempty"`
	NotFound   []string             `json:"NotFound,omitempty"`
}

type BasicAuth ¶

type BasicAuth struct {
	UserName string `json:"userName,omitempty"`
	Password string `json:"password,omitempty"`
}

BasicAuth provides basic http authentication to a request passed via context using ContextBasicAuth

type CliDangerThisWillDeleteAllComponentEndpointsContinueApiService ¶

type CliDangerThisWillDeleteAllComponentEndpointsContinueApiService service

func (*CliDangerThisWillDeleteAllComponentEndpointsContinueApiService) DoComponentEndpointsDeleteAll ¶

func (a *CliDangerThisWillDeleteAllComponentEndpointsContinueApiService) DoComponentEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllComponentEndpointsContinueApiService Delete all ComponentEndpoints Delete all entries in the ComponentEndpoint collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService ¶

type CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService service

func (*CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService) DoCompEthInterfaceDeleteAllV2 ¶

func (a *CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService) DoCompEthInterfaceDeleteAllV2(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllComponentEthernetInterfacesContinueApiService Clear the component Ethernet interface collection. Delete all component Ethernet interface entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllComponentsInHSMContinueApiService ¶

type CliDangerThisWillDeleteAllComponentsInHSMContinueApiService service

func (*CliDangerThisWillDeleteAllComponentsInHSMContinueApiService) DoComponentsDeleteAll ¶

func (a *CliDangerThisWillDeleteAllComponentsInHSMContinueApiService) DoComponentsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllComponentsInHSMContinueApiService Delete all components Delete all entries in the components collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllFRUsForHSMContinueApiService ¶

type CliDangerThisWillDeleteAllFRUsForHSMContinueApiService service

func (*CliDangerThisWillDeleteAllFRUsForHSMContinueApiService) DoHWInvByFRUDeleteAll ¶

func (a *CliDangerThisWillDeleteAllFRUsForHSMContinueApiService) DoHWInvByFRUDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllFRUsForHSMContinueApiService Delete all HWInventoryByFRU entries Delete all entries in the HWInventoryByFRU collection. Note that this does not delete any associated HWInventoryByLocation entries. Also, if any items are associated with a HWInventoryByLocation, the deletion will fail.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllHardwareHistoryContinueApiService ¶

type CliDangerThisWillDeleteAllHardwareHistoryContinueApiService service

func (*CliDangerThisWillDeleteAllHardwareHistoryContinueApiService) DoHWInvHistByLocationDeleteAll ¶

func (a *CliDangerThisWillDeleteAllHardwareHistoryContinueApiService) DoHWInvHistByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllHardwareHistoryContinueApiService Clear the HWInventory history. Delete all HWInventory history entries. Note that this also deletes history for any associated HWInventoryByFRU entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllHardwareInventoryContinueApiService ¶

type CliDangerThisWillDeleteAllHardwareInventoryContinueApiService service

func (*CliDangerThisWillDeleteAllHardwareInventoryContinueApiService) DoHWInvByLocationDeleteAll ¶

func (a *CliDangerThisWillDeleteAllHardwareInventoryContinueApiService) DoHWInvByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllHardwareInventoryContinueApiService Delete all HWInventoryByLocation entries Delete all entries in the HWInventoryByLocation collection. Note that this does not delete any associated HWInventoryByFRU entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService ¶

type CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService service

func (*CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService) DoHWInvHistByFRUDelete ¶

func (a *CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService) DoHWInvHistByFRUDelete(ctx context.Context, fruid string) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllHistoryForThisFRUContinueApiService Delete history for the HWInventoryByFRU entry with FRU identifier {fruid} Delete history for an entry in the HWInventoryByFRU collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param fruid Locational xname of HWInventoryByFRU record to delete history for.

@return Response100

type CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService ¶

type CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService service

func (*CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService) DoHWInvHistByLocationDelete ¶

func (a *CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService) DoHWInvHistByLocationDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllHistoryForThisXnameContinueApiService DELETE history for the HWInventoryByLocation entry with ID (location) {xname} Delete history for the HWInventoryByLocation entry for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of HWInventoryByLocation record to delete history for.

@return Response100

type CliDangerThisWillDeleteAllNodeMapsContinueApiService ¶

type CliDangerThisWillDeleteAllNodeMapsContinueApiService service

func (*CliDangerThisWillDeleteAllNodeMapsContinueApiService) DoNodeMapsDeleteAll ¶

func (a *CliDangerThisWillDeleteAllNodeMapsContinueApiService) DoNodeMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllNodeMapsContinueApiService Delete all NodeMap entities Delete all entries in the NodeMaps collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService ¶

type CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService service

func (*CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService) DoRedfishEndpointsDeleteAll ¶

func (a *CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService) DoRedfishEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllRedfishEndpointsInHSMContinueApiService Delete all RedfishEndpoints Delete all entries in the RedfishEndpoint collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliDangerThisWillDeleteAllServiceEndpointsContinueApiService ¶

type CliDangerThisWillDeleteAllServiceEndpointsContinueApiService service

func (*CliDangerThisWillDeleteAllServiceEndpointsContinueApiService) DoServiceEndpointsDeleteAll ¶

func (a *CliDangerThisWillDeleteAllServiceEndpointsContinueApiService) DoServiceEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliDangerThisWillDeleteAllServiceEndpointsContinueApiService Delete all ServiceEndpoints Delete all entries in the ServiceEndpoint collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

type CliIgnoreApiService ¶

type CliIgnoreApiService service

func (*CliIgnoreApiService) DoDeleteSCNSubscription ¶

func (a *CliIgnoreApiService) DoDeleteSCNSubscription(ctx context.Context, id string) (*http.Response, error)

CliIgnoreApiService Delete a state change notification subscription Delete a state change notification subscription.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id This is the ID associated with the subscription that was generated at its creation.

func (*CliIgnoreApiService) DoDeleteSCNSubscriptionsAll ¶

func (a *CliIgnoreApiService) DoDeleteSCNSubscriptionsAll(ctx context.Context) (*http.Response, error)

CliIgnoreApiService Delete all state change notification subscriptions Delete all subscriptions.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

func (*CliIgnoreApiService) DoGetSCNSubscription ¶

func (a *CliIgnoreApiService) DoGetSCNSubscription(ctx context.Context, id string) (SubscriptionsScnPostSubscription, *http.Response, error)

CliIgnoreApiService Retrieve a currently-held state change notification subscription Return the information on a currently held state change notification subscription

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id This is the ID associated with the subscription that was generated at its creation.

@return SubscriptionsScnPostSubscription

func (*CliIgnoreApiService) DoGetSCNSubscriptionsAll ¶

func (a *CliIgnoreApiService) DoGetSCNSubscriptionsAll(ctx context.Context) (SubscriptionsScnSubscriptionArray, *http.Response, error)

CliIgnoreApiService Retrieve currently-held state change notification subscriptions Retrieve all information on currently held state change notification subscriptions.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return SubscriptionsScnSubscriptionArray

func (*CliIgnoreApiService) DoHWInvByLocationPost ¶

func (a *CliIgnoreApiService) DoHWInvByLocationPost(ctx context.Context, body InventoryHardwareBody) (Response100, *http.Response, error)

CliIgnoreApiService Create/Update hardware inventory entries Create/Update hardware inventory entries

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return Response100

func (*CliIgnoreApiService) DoPatchSCNSubscription ¶

func (a *CliIgnoreApiService) DoPatchSCNSubscription(ctx context.Context, body SubscriptionsScnPatchSubscription, id string) (*http.Response, error)

CliIgnoreApiService Update a subscription for state change notifications Update a subscription for state change notifications to add or remove triggers.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param id This is the ID associated with the subscription that was generated at its creation.

func (*CliIgnoreApiService) DoPostSCNSubscription ¶

func (a *CliIgnoreApiService) DoPostSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription) (SubscriptionsScnSubscriptionArrayItem100, *http.Response, error)

CliIgnoreApiService Create a subscription for state change notifications Request a subscription for state change notifications for a set of component states. This will create a new subscription and produce a unique ID for the subscription. This will not affect the existing subscriptions.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return SubscriptionsScnSubscriptionArrayItem100

func (*CliIgnoreApiService) DoPowerMapsDeleteAll ¶

func (a *CliIgnoreApiService) DoPowerMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

CliIgnoreApiService Delete all PowerMap entities Delete all entries in the PowerMaps collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*CliIgnoreApiService) DoPutSCNSubscription ¶

func (a *CliIgnoreApiService) DoPutSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription, id string) (*http.Response, error)

CliIgnoreApiService Update a subscription for state change notifications Update an existing state change notification subscription in whole. This will overwrite the specified subscription.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param id This is the ID associated with the subscription that was generated at its creation.

func (*CliIgnoreApiService) DoRedfishEndpointPut ¶

func (a *CliIgnoreApiService) DoRedfishEndpointPut(ctx context.Context, body RedfishEndpoint100RedfishEndpoint, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)

CliIgnoreApiService Update definition for RedfishEndpoint ID {xname} Create or update RedfishEndpoint record for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of RedfishEndpoint record to create or update.

@return RedfishEndpoint100RedfishEndpoint

func (*CliIgnoreApiService) LocksReservationsPost ¶

func (a *CliIgnoreApiService) LocksReservationsPost(ctx context.Context, body AdminReservationCreate100) (AdminReservationCreateResponse100, *http.Response, error)

CliIgnoreApiService Create reservations Creates reservations on a set of xnames of infinite duration. Component must be locked to create a reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to create reservations. A `rigid` processing model will result in the entire set of xnames not having reservations created if an xname doesn't exist, or isn't locked, or if already reserved. A `flexible` processing model will perform all actions possible.

@return AdminReservationCreateResponse100

func (*CliIgnoreApiService) LocksReservationsReleasePost ¶

func (a *CliIgnoreApiService) LocksReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)

CliIgnoreApiService Releases existing reservations. Given a list of {xname & reservation key}, releases the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to release reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation released if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*CliIgnoreApiService) LocksReservationsRemovePost ¶

func (a *CliIgnoreApiService) LocksReservationsRemovePost(ctx context.Context, body AdminReservationRemove100) (XnameResponse100, *http.Response, error)

CliIgnoreApiService Forcibly deletes existing reservations. Given a list of components, forcibly deletes any existing reservation. Does not change lock state; does not disable the reservation ability of the component. An empty set of xnames will delete reservations on all xnames. This functionality should be used sparingly, the normal flow should be to release reservations, versus removing them.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to remove reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation removed if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*CliIgnoreApiService) LocksServiceReservationsCheckPost ¶

func (a *CliIgnoreApiService) LocksServiceReservationsCheckPost(ctx context.Context, body DeputyKeys100) (ServiceReservationCheckResponse100, *http.Response, error)

CliIgnoreApiService Check the validity of reservations. Using xname + reservation key check on the validity of reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components & deputy keys to check on validity of reservations.

@return ServiceReservationCheckResponse100

func (*CliIgnoreApiService) LocksServiceReservationsPost ¶

func (a *CliIgnoreApiService) LocksServiceReservationsPost(ctx context.Context, body ServiceReservationCreate100) (ServiceReservationCreateResponse100, *http.Response, error)

CliIgnoreApiService Create reservations Creates reservations on a set of xnames of finite duration. Component must be unlocked to create a reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to create reservations. A `rigid` processing model will result in the entire set of xnames not having reservations created if an xname doesn't exist, or isn't locked, or if already reserved. A `flexible` processing model will perform all actions possible.

@return ServiceReservationCreateResponse100

func (*CliIgnoreApiService) LocksServiceReservationsReleasePost ¶

func (a *CliIgnoreApiService) LocksServiceReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)

CliIgnoreApiService Releases existing reservations. Given a list of {xname & reservation key}, releases the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to release reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation released if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*CliIgnoreApiService) LocksServiceReservationsRenewPost ¶

func (a *CliIgnoreApiService) LocksServiceReservationsRenewPost(ctx context.Context, body ReservedKeysWithRenewal100) (XnameResponse100, *http.Response, error)

CliIgnoreApiService Renew existing reservations. Given a list of {xname & reservation key}, renews the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to renew reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation renewed if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

type CompEthInterface100 ¶

type CompEthInterface100 struct {
	// The ID of the component Ethernet interface.
	ID string `json:"ID,omitempty"`
	// An optional description for the component Ethernet interface.
	Description string `json:"Description,omitempty"`
	// The MAC address of this component Ethernet interface
	MACAddress string `json:"MACAddress"`
	// The IP addresses associated with the MAC address for this component Ethernet interface.
	IPAddresses []CompEthInterface100IpAddressMapping `json:"IPAddresses,omitempty"`
	// A timestamp for when the component Ethernet interface last was modified.
	LastUpdate  time.Time   `json:"LastUpdate,omitempty"`
	ComponentID string      `json:"ComponentID,omitempty"`
	Type_       *HmsType100 `json:"Type,omitempty"`
}

A component Ethernet interface is an object describing a relation between a MAC address and IP address for components.

type CompEthInterface100IpAddressMapping ¶

type CompEthInterface100IpAddressMapping struct {
	// The IP address associated with the MAC address for this component Ethernet interface on for this particular network.
	IPAddress string `json:"IPAddress"`
	// The network that this IP addresses is associated with.
	Network string `json:"Network,omitempty"`
}

A IP address Mapping maps a IP address to a network. In a Component Ethernet Interface it is used to describe what IP addresses and their networks that are associated with it.

type CompEthInterface100IpAddressMappingPatch ¶

type CompEthInterface100IpAddressMappingPatch struct {
	// The network that this IP addresses is associated with.
	Network string `json:"Network,omitempty"`
}

To update the network field a IP address mapping in a component Ethernet interface a PATCH operation can be used. Omitted fields are not updated.

type CompEthInterface100Patch ¶

type CompEthInterface100Patch struct {
	// An optional description for the component Ethernet interface.
	Description string `json:"Description,omitempty"`
	// The IP addresses associated with the MAC address for this component Ethernet interface.
	IPAddresses []CompEthInterface100IpAddressMapping `json:"IPAddresses,omitempty"`
	ComponentID string                                `json:"ComponentID,omitempty"`
}

To update the IP addresses, CompID, and/or description fields of a component Ethernet interface, a PATCH operation can be used. Omitted fields are not updated. NOTE: Updating the IP addresses field updates the LastUpdate field.

type Component100Component ¶

type Component100Component struct {
	ID    string       `json:"ID,omitempty"`
	Type_ *HmsType100  `json:"Type,omitempty"`
	State *HmsState100 `json:"State,omitempty"`
	Flag  *HmsFlag100  `json:"Flag,omitempty"`
	// Whether component is enabled. True when enabled, false when disabled.
	Enabled bool `json:"Enabled,omitempty"`
	// SoftwareStatus of a node, used by the managed plane for running nodes.  Will be missing for other component types or if not set by software.
	SoftwareStatus string `json:"SoftwareStatus,omitempty"`
	Role           string `json:"Role,omitempty"`
	SubRole        string `json:"SubRole,omitempty"`
	// This is the integer Node ID if the component is a node.
	NID int32 `json:"NID,omitempty"`
	// Further distinguishes between components of same type.
	Subtype string       `json:"Subtype,omitempty"`
	NetType *NetType100  `json:"NetType,omitempty"`
	Arch    *HmsArch100  `json:"Arch,omitempty"`
	Class   *HmsClass100 `json:"Class,omitempty"`
	// Whether component can be reserved via the locking API. True when reservations are disabled, thus no new reservations can be created on this component.
	ReservationDisabled bool `json:"ReservationDisabled,omitempty"`
	// Whether a component is locked via the locking API.
	Locked bool `json:"Locked,omitempty"`
}

This is the logical representation of a component for which state is tracked and includes other variables that may be needed by clients. It is keyed by the physical location i.e. xname.

type Component100ComponentCreate ¶

type Component100ComponentCreate struct {
	ID    string       `json:"ID"`
	State *HmsState100 `json:"State"`
	Flag  *HmsFlag100  `json:"Flag,omitempty"`
	// Whether component is enabled. True when enabled, false when disabled.
	Enabled bool `json:"Enabled,omitempty"`
	// SoftwareStatus of a node, used by the managed plane for running nodes.  Will be missing for other component types or if not set by software.
	SoftwareStatus string `json:"SoftwareStatus,omitempty"`
	Role           string `json:"Role,omitempty"`
	SubRole        string `json:"SubRole,omitempty"`
	// This is the integer Node ID if the component is a node.
	NID int32 `json:"NID,omitempty"`
	// Further distinguishes between components of same type.
	Subtype string       `json:"Subtype,omitempty"`
	NetType *NetType100  `json:"NetType,omitempty"`
	Arch    *HmsArch100  `json:"Arch,omitempty"`
	Class   *HmsClass100 `json:"Class,omitempty"`
}

This is the logical representation of a component for which state is tracked and includes other variables that may be needed by clients. It is keyed by the physical location i.e. xname.

type Component100PatchArrayItemNid ¶

type Component100PatchArrayItemNid struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the integer Node ID if the component is a node.
	NID          int32                   `json:"NID"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is one entry in a NID patch operation on an entire ComponentArray. ID and NID are required or the operation will fail. Only the NID field is updated, and then only if it is appropriate for the corresponding HMS type of the entry (e.g. node).

type Component100PatchEnabled ¶

type Component100PatchEnabled struct {
	// Component Enabled(true)/Disabled(false) flag
	Enabled      bool                    `json:"Enabled"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is the payload of a Enabled patch operation on a Component. Enabled is required, and is a boolean field with true representing enabled and false disabled.

type Component100PatchFlagOnly ¶

type Component100PatchFlagOnly struct {
	Flag         *HmsFlag100             `json:"Flag"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is the payload of a FlagOnly patch operation on a component. Flag is required and the State field is unmodified regardless of the value given.

type Component100PatchNid ¶

type Component100PatchNid struct {
	// This is the integer Node ID if the component is a node.
	NID          int32                   `json:"NID"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is the payload of a NID patch operation on a Component. NID is required but the operation will fail if NID is not a valid

type Component100PatchRole ¶

type Component100PatchRole struct {
	Role         string                  `json:"Role"`
	SubRole      string                  `json:"SubRole,omitempty"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is the payload of a Role patch operation on a Component. Role is required, however operation will fail if Role is not a supported property of the corresponding HMS type.

type Component100PatchSoftwareStatus ¶

type Component100PatchSoftwareStatus struct {
	// Component/node software status field, reserved for managed plane.
	SoftwareStatus string                  `json:"SoftwareStatus,omitempty"`
	ExtendedInfo   *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is the payload of a SoftwareStatus patch operation on a Component.

type Component100PatchStateData ¶

type Component100PatchStateData struct {
	State *HmsState100 `json:"State"`
	Flag  *HmsFlag100  `json:"Flag,omitempty"`
	// If the state change is normally prohibited, due to the current and new states, force the change anyways.  Default is false.
	Force        bool                    `json:"Force,omitempty"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is the payload of a StateData URI patch operation on a component. Flag ID optional and will be reset to OK if no Flag value is given.

type Component100Put ¶

type Component100Put struct {
	Component *Component100ComponentCreate `json:"Component"`
	// If true, 'force' causes this operation to overwrite the 'State', 'Flag', 'Subtype', 'NetType', and 'Arch' fields for the specified component if it already exists. Otherwise, nothing will be overwritten.
	Force bool `json:"Force,omitempty"`
}

This is the payload of a state components URI put operation on a component.

type Component100ResourceUriCollection ¶

type Component100ResourceUriCollection struct {
	// Should describe the collection, though the type of resources the links correspond to should also be inferred from the context in which the collection was obtained.
	Name string `json:"Name,omitempty"`
	// An array of ResourceIds.
	Members []ResourceUri100 `json:"Members,omitempty"`
	// Number of ResourceURIs in the collection
	MemberCount float64 `json:"MemberCount,omitempty"`
}

type ComponentApiDoComponentQueryGetOpts ¶

type ComponentApiDoComponentQueryGetOpts struct {
	Type_          optional.String
	State          optional.String
	Flag           optional.String
	Role           optional.String
	Subrole        optional.String
	Enabled        optional.String
	Softwarestatus optional.String
	Subtype        optional.String
	Arch           optional.String
	Class          optional.String
	Nid            optional.String
	NidStart       optional.String
	NidEnd         optional.String
	Partition      optional.String
	Group          optional.String
	Stateonly      optional.Bool
	Flagonly       optional.Bool
	Roleonly       optional.Bool
	Nidonly        optional.Bool
}

type ComponentApiDoComponentsGetOpts ¶

type ComponentApiDoComponentsGetOpts struct {
	Id             optional.String
	Type_          optional.String
	State          optional.String
	Flag           optional.String
	Role           optional.String
	Subrole        optional.String
	Enabled        optional.String
	Softwarestatus optional.String
	Subtype        optional.String
	Arch           optional.String
	Class          optional.String
	Nid            optional.String
	NidStart       optional.String
	NidEnd         optional.String
	Partition      optional.String
	Group          optional.String
	Stateonly      optional.Bool
	Flagonly       optional.Bool
	Roleonly       optional.Bool
	Nidonly        optional.Bool
}

type ComponentApiService ¶

type ComponentApiService service

func (*ComponentApiService) DoCompArrayNIDPatch ¶

func (a *ComponentApiService) DoCompArrayNIDPatch(ctx context.Context, body ComponentArrayPatchArrayNid) (*http.Response, error)

ComponentApiService Update multiple components' NIDs via ComponentArray Modify the submitted ComponentArray and update the corresponding NID value for each entry. Other fields are ignored and not changed. ID field is required for all entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoCompBulkEnabledPatch ¶

func (a *ComponentApiService) DoCompBulkEnabledPatch(ctx context.Context, body ComponentArrayPatchArrayEnabled) (*http.Response, error)

ComponentApiService Update multiple components' Enabled values via a list of xnames Update the Enabled field for a list of xnames. Specify a single value for Enabled and also the list of xnames. Note that Enabled is a boolean field and a value of false sets the component(s) to disabled.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoCompBulkFlagOnlyPatch ¶

func (a *ComponentApiService) DoCompBulkFlagOnlyPatch(ctx context.Context, body ComponentArrayPatchArrayFlagOnly) (*http.Response, error)

ComponentApiService Update multiple components' Flag values via a list of xnames Specify a list of xnames to update the Flag field and specify the value. The list of IDs and the new Flag are required.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoCompBulkRolePatch ¶

func (a *ComponentApiService) DoCompBulkRolePatch(ctx context.Context, body ComponentArrayPatchArrayRole) (*http.Response, error)

ComponentApiService Update multiple components' Role values via a list of xnames Update the Role and SubRole field for a list of xnames. Specify the Role and Subrole values and the list of xnames. The list of IDs and the new Role are required.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoCompBulkStateDataPatch ¶

func (a *ComponentApiService) DoCompBulkStateDataPatch(ctx context.Context, body ComponentArrayPatchArrayStateData) (*http.Response, error)

ComponentApiService Update multiple components' state data via a list of xnames Specify a list of xnames to update the State and Flag fields. If the Flag field is omitted, Flag is reverted to 'OK'. Other fields are ignored. The list of IDs and the new State are required.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoCompBulkSwStatusPatch ¶

func (a *ComponentApiService) DoCompBulkSwStatusPatch(ctx context.Context, body ComponentArrayPatchArraySoftwareStatus) (*http.Response, error)

ComponentApiService Update multiple components' SoftwareStatus values via a list of xnames Update the SoftwareStatus field for a list of xnames. Specify a single new value of SoftwareStatus like admindown and the list of xnames.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoCompEnabledPatch ¶

func (a *ComponentApiService) DoCompEnabledPatch(ctx context.Context, body Component100PatchEnabled, xname string) (*http.Response, error)

ComponentApiService Update component Enabled value at {xname} Update the component's Enabled field only. The State and other fields are not modified. Note that this is a boolean field, a value of false sets the component to disabled.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of component to set Enabled to true or false.

func (*ComponentApiService) DoCompFlagOnlyPatch ¶

func (a *ComponentApiService) DoCompFlagOnlyPatch(ctx context.Context, body Component100PatchFlagOnly, xname string) (*http.Response, error)

ComponentApiService Update component Flag value at {xname} The State is not modified. Only the Flag is updated.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of component to modify flag on.

func (*ComponentApiService) DoCompNIDPatch ¶

func (a *ComponentApiService) DoCompNIDPatch(ctx context.Context, body Component100PatchNid, xname string) (*http.Response, error)

ComponentApiService Update component NID value at {xname} Update the component's NID field only. Valid only for nodes. State and other fields are not modified.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of component to modify NID on.

func (*ComponentApiService) DoCompRolePatch ¶

func (a *ComponentApiService) DoCompRolePatch(ctx context.Context, body Component100PatchRole, xname string) (*http.Response, error)

ComponentApiService Update component Role and SubRole values at {xname} Update the component's Role and SubRole fields only. Valid only for nodes. The State and other fields are not modified.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of component to modify Role on.

func (*ComponentApiService) DoCompStatePatch ¶

func (a *ComponentApiService) DoCompStatePatch(ctx context.Context, body Component100PatchStateData, xname string) (*http.Response, error)

ComponentApiService Update component state data at {xname} Update the component's state and flag fields only. If Flag field is omitted, the Flag value is reverted to 'OK'.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of component to set state/flag on.

func (*ComponentApiService) DoCompSwStatusPatch ¶

func (a *ComponentApiService) DoCompSwStatusPatch(ctx context.Context, body Component100PatchSoftwareStatus, xname string) (*http.Response, error)

ComponentApiService Update component SoftwareStatus value at {xname} Update the component's SoftwareStatus field only. The State and other fields are not modified.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of component to set new SoftwareStatus value.

func (*ComponentApiService) DoComponentByNIDGet ¶

func (a *ComponentApiService) DoComponentByNIDGet(ctx context.Context, nid string) (Component100Component, *http.Response, error)

ComponentApiService Retrieve component with NID={nid} Retrieve a component by NID.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param nid NID of component to return.

@return Component100Component

func (*ComponentApiService) DoComponentByNIDQueryPost ¶

func (a *ComponentApiService) DoComponentByNIDQueryPost(ctx context.Context, body ComponentArrayPostByNidQuery) (ComponentArrayComponentArray, *http.Response, error)

ComponentApiService Create component query (by NID ranges), returning ComponentArray Retrieve the targeted entries in the form of a ComponentArray by providing a payload of NID ranges.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return ComponentArrayComponentArray

func (*ComponentApiService) DoComponentDelete ¶

func (a *ComponentApiService) DoComponentDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

ComponentApiService Delete component with ID {xname} Delete a component by xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of component record to delete.

@return Response100

func (*ComponentApiService) DoComponentGet ¶

func (a *ComponentApiService) DoComponentGet(ctx context.Context, xname string) (Component100Component, *http.Response, error)

ComponentApiService Retrieve component at {xname} Retrieve state or components by xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of component to return.

@return Component100Component

func (*ComponentApiService) DoComponentPut ¶

func (a *ComponentApiService) DoComponentPut(ctx context.Context, body Component100Put, xname string) (*http.Response, error)

ComponentApiService Create/Update an HMS Component Create/Update a state/component. If the component already exists it will not be overwritten unless force=true in which case State, Flag, Subtype, NetType, Arch, and Class will get overwritten.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of the component to create or update.

func (*ComponentApiService) DoComponentQueryGet ¶

func (a *ComponentApiService) DoComponentQueryGet(ctx context.Context, xname string, localVarOptionals *ComponentApiDoComponentQueryGetOpts) (ComponentArrayComponentArray, *http.Response, error)

func (*ComponentApiService) DoComponentsDeleteAll ¶

func (a *ComponentApiService) DoComponentsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

ComponentApiService Delete all components Delete all entries in the components collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*ComponentApiService) DoComponentsGet ¶

func (a *ComponentApiService) DoComponentsGet(ctx context.Context, localVarOptionals *ComponentApiDoComponentsGetOpts) (ComponentArrayComponentArray, *http.Response, error)

func (*ComponentApiService) DoComponentsPost ¶

func (a *ComponentApiService) DoComponentsPost(ctx context.Context, body ComponentArrayPostArray) (*http.Response, error)

ComponentApiService Create/Update a collection of HMS Components Create/Update a collection of state/components. If the component already exists it will not be overwritten unless force=true in which case State, Flag, Subtype, NetType, Arch, and Class will get overwritten.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

func (*ComponentApiService) DoComponentsQueryPost ¶

func (a *ComponentApiService) DoComponentsQueryPost(ctx context.Context, body ComponentArrayPostQuery) (ComponentArrayComponentArray, *http.Response, error)

ComponentApiService Create component query (by xname list), returning ComponentArray Retrieve the targeted entries in the form of a ComponentArray by providing a payload of component IDs.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return ComponentArrayComponentArray

type ComponentArrayComponentArray ¶

type ComponentArrayComponentArray struct {
	// Contains the HMS component objects in the array.
	Components []Component100Component `json:"Components,omitempty"`
}

This is a collection of Component objects returned whenever a query is expected to result in 0 to n matches.

type ComponentArrayPatchArrayEnabled ¶

type ComponentArrayPatchArrayEnabled struct {
	// An array of XName/ID values for the components to update.
	ComponentIDs []string `json:"ComponentIDs"`
	// Whether component is enabled. True when enabled, false when disabled.
	Enabled      bool                    `json:"Enabled"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is a component Enabled field patch request. Contains the new value of enabled to apply and the list of component xnames to update.

type ComponentArrayPatchArrayFlagOnly ¶

type ComponentArrayPatchArrayFlagOnly struct {
	// An array of XName/ID values for the components to update.
	ComponentIDs []string                `json:"ComponentIDs"`
	Flag         *HmsFlag100             `json:"Flag"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is a component flag value patch request. Contains the new flag to apply and a list of component xnames for update.

type ComponentArrayPatchArrayNid ¶

type ComponentArrayPatchArrayNid struct {
	// Descriptive name e.g. why it was generated.
	Name string `json:"Name,omitempty"`
	// Contains the component objects in the array but with just the Component ID and the patchable fields for a NID patch operation filled in.  Other Component fields are not undated during these operations.
	Components []Component100PatchArrayItemNid `json:"Components,omitempty"`
}

This is a collection of Component objects with just the ID and NID fields populated.

type ComponentArrayPatchArrayRole ¶

type ComponentArrayPatchArrayRole struct {
	// An array of XName/ID values for the components to update.
	ComponentIDs []string                `json:"ComponentIDs"`
	Role         string                  `json:"Role"`
	SubRole      string                  `json:"SubRole,omitempty"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is a component Role value patch request. Contains the new Role to apply and a list of component xnames for update.

type ComponentArrayPatchArraySoftwareStatus ¶

type ComponentArrayPatchArraySoftwareStatus struct {
	// An array of XName/ID values for the components to update.
	ComponentIDs []string `json:"ComponentIDs"`
	// SoftwareStatus of the node, used by the managed plane for running nodes.
	SoftwareStatus string                  `json:"SoftwareStatus"`
	ExtendedInfo   *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is a component SoftwareStatus field patch request. Contains a new, single value of SoftwareStatus to apply, and the list of component xnames to update.

type ComponentArrayPatchArrayStateData ¶

type ComponentArrayPatchArrayStateData struct {
	// An array of XName/ID values for the components to update.
	ComponentIDs []string     `json:"ComponentIDs"`
	State        *HmsState100 `json:"State"`
	Flag         *HmsFlag100  `json:"Flag,omitempty"`
	// If the state change is normally prohibited, due to the current and new states, force the change anyways.  Default is false.
	Force        bool                    `json:"Force,omitempty"`
	ExtendedInfo *Message100ExtendedInfo `json:"ExtendedInfo,omitempty"`
}

This is a component state data patch request. Contains the new state to apply, new flag to apply (optional), and a list of component xnames for update. If the component flag is omitted, the flag will be reset to 'ok'.

type ComponentArrayPostArray ¶

type ComponentArrayPostArray struct {
	// Contains the HMS component objects in the array.
	Components []Component100ComponentCreate `json:"Components"`
	// If true, 'force' causes this operation to overwrite the 'State', 'Flag', 'Subtype', 'NetType', and 'Arch' fields for the specified component if it already exists. Otherwise, nothing will be overwritten.
	Force bool `json:"Force,omitempty"`
}

This is a component post request. Contains the new component fields to apply.

type ComponentArrayPostByNidQuery ¶

type ComponentArrayPostByNidQuery struct {
	// NID range values to query, producing a ComponentArray with the matching components, e.g. \"0-24\" or \"2\".  Add each multiple ranges as a separate array item.
	NIDRanges []string `json:"NIDRanges"`
	Partition string   `json:"partition,omitempty"`
	// Return only component state and flag fields (plus xname/ID and type).  Results can be modified and used for bulk state/flag- only patch operations.
	Stateonly bool `json:"stateonly,omitempty"`
	// Return only component flag field (plus xname/ID and type). Results can be modified and used for bulk flag-only patch operations.
	Flagonly bool `json:"flagonly,omitempty"`
	// Return only component role and subrole fields (plus xname/ID and type). Results can be modified and used for bulk role-only patches.
	Roleonly bool `json:"roleonly,omitempty"`
	// Return only component NID field (plus xname/ID and type). Results can be modified and used for bulk NID-only patches.
	Nidonly bool `json:"nidonly,omitempty"`
}

There are limits to the length of an HTTP URL and query string. Hence, if we wish to query an arbitrary list of NIDs, it will need to be in the body of the request. This object is used for this purpose. Parameters are similar to the analogous GET operation.

type ComponentArrayPostQuery ¶

type ComponentArrayPostQuery struct {
	// An array of XName/ID values for the components to query.
	ComponentIDs []string `json:"ComponentIDs,omitempty"`
	// Partition name to filter on, as per current /partitions/names
	Partition string `json:"partition,omitempty"`
	// Group label to filter on, as per current /groups/labels
	Group string `json:"group,omitempty"`
	// Return only component state and flag fields (plus xname/ID and type).  Results can be modified and used for bulk state/flag- only patch operations.
	Stateonly bool `json:"stateonly,omitempty"`
	// Return only component flag field (plus xname/ID and type). Results can be modified and used for bulk flag-only patch operations.
	Flagonly bool `json:"flagonly,omitempty"`
	// Return only component role and subrole fields (plus xname/ID and type). Results can be modified and used for bulk role-only patches.
	Roleonly bool `json:"roleonly,omitempty"`
	// Return only component NID field (plus xname/ID and type). Results can be modified and used for bulk NID-only patches.
	Nidonly bool `json:"nidonly,omitempty"`
	// Retrieve all components with the given HMS type.
	Type_ []string `json:"type,omitempty"`
	// Retrieve all components with the given HMS state.
	State []string `json:"state,omitempty"`
	// Retrieve all components with the given HMS flag value.
	Flag []string `json:"flag,omitempty"`
	// Retrieve all components with the given enabled status (true or false).
	Enabled []string `json:"enabled,omitempty"`
	// Retrieve all components with the given software status. Software status is a free form string. Matching is case-insensitive.
	Softwarestatus []string `json:"softwarestatus,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS role
	Role []string `json:"role,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS subrole
	Subrole []string `json:"subrole,omitempty"`
	// Retrieve all components with the given HMS subtype.
	Subtype []string `json:"subtype,omitempty"`
	// Retrieve all components with the given architecture.
	Arch []string `json:"arch,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS hardware class. Class can be River, Mountain, etc.
	Class []string `json:"class,omitempty"`
	// Retrieve all components (i.e. one node) with the given integer NID
	Nid []string `json:"nid,omitempty"`
	// Retrieve all components (i.e. nodes) with NIDs equal to or greater than the provided integer.
	NidStart []string `json:"nid_start,omitempty"`
	// Retrieve all components (i.e. nodes) with NIDs less than or equal to the provided integer.
	NidEnd []string `json:"nid_end,omitempty"`
}

There are limits to the length of an HTTP URL and query string. Hence, if we wish to query an arbitrary list of XName/IDs, it will need to be in the body of the request. This object is used for this purpose. It is similar to the analogous GET operation.

type ComponentByNid100ResourceUriCollection ¶

type ComponentByNid100ResourceUriCollection struct {
	// Should describe the collection, though the type of resources the links correspond to should also be inferred from the context in which the collection was obtained.
	Name string `json:"Name,omitempty"`
	// An array of ResourceIds.
	Members []ResourceUri100 `json:"Members,omitempty"`
	// Number of ResourceURIs in the collection
	MemberCount float64 `json:"MemberCount,omitempty"`
}

type ComponentEndpoint100ComponentEndpoint ¶

type ComponentEndpoint100ComponentEndpoint struct {
	ID    string      `json:"ID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// Domain of component FQDN.  Hostname is always ID/xname
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of component on management network if for example the component is a node.
	FQDN           string             `json:"FQDN,omitempty"`
	RedfishType    *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool `json:"Enabled,omitempty"`
	// This is used as a discriminator to determine the additional RF-type- specific data that is kept for a ComponentEndpoint.
	ComponentEndpointType string `json:"ComponentEndpointType"`
	// If the component e.g. a ComputerSystem/Node has a MAC on the management network, i.e. corresponding to the FQDN field's Ethernet interface, this field will be present.  Not the HSN MAC.  Represented as the standard colon-separated 6 byte hex string.
	MACAddr           string `json:"MACAddr,omitempty"`
	UUID              string `json:"UUID,omitempty"`
	OdataID           string `json:"OdataID,omitempty"`
	RedfishEndpointID string `json:"RedfishEndpointID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// Complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL string `json:"RedfishURL,omitempty"`
}

This describes a child component of a Redfish endpoint and is populated when Redfish endpoint discovery occurs. It is used by services that need to interact directly with the component via Redfish. It represents a physical component of something and has a corresponding representation as an HMS Component, hence the name. There are also ServiceEndpoints which represent Redfish services that are discovered when the RedfishEndpoint is discovered. NOTE: These records are discovered, not created, and therefore are not writable (since any changes would be overwritten by a subsequent discovery). Additional info is appended depending on RedfishType (discriminator)

type ComponentEndpoint100RedfishChassisInfo ¶

type ComponentEndpoint100RedfishChassisInfo struct {
	// The Redfish 'Name' of the Chassis.
	Name    string                    `json:"Name,omitempty"`
	Actions *Actions100ChassisActions `json:"Actions,omitempty"`
}

This is the ChassisInfo field in the RF Chassis subtype of ComponentEndpoint, i.e. when the latter's RedfishType is Chassis. This is where new fields will be added.

type ComponentEndpoint100RedfishManagerInfo ¶

type ComponentEndpoint100RedfishManagerInfo struct {
	// The Redfish 'Name' of the Manager.
	Name            string                    `json:"Name,omitempty"`
	Actions         *Actions100ManagerActions `json:"Actions,omitempty"`
	EthernetNICInfo []EthernetNicInfo100      `json:"EthernetNICInfo,omitempty"`
}

This is the ManagerInfo object in the RF Manager subtype of ComponentEndpoint, i.e. when the latter's RedfishType is Manager. It contains BMC/Manager-specific Redfish fields that need to be collected during discovery and made available to clients. This is where new fields will be added. Mostly placeholder now.

type ComponentEndpoint100RedfishOutletInfo ¶

type ComponentEndpoint100RedfishOutletInfo struct {
	// The Redfish Name of the Outlet.
	Name    string                   `json:"Name,omitempty"`
	Actions *Actions100OutletActions `json:"Actions,omitempty"`
}

This is the RedfishOutletInfo field in the RF Outlet subtype of ComponentEndpoint, i.e. when the latter's RedfishType is Outlet. This is where new fields will be added.

type ComponentEndpoint100RedfishPowerDistributionInfo ¶

type ComponentEndpoint100RedfishPowerDistributionInfo struct {
	// The Redfish Name of the PDU.
	Name string `json:"Name,omitempty"`
}

This is the RedfishPDUInfo field in the RF Chassis subtype of ComponentEndpoint, i.e. when the latter's RedfishType is PowerDistribution. This is where new fields will be added.

type ComponentEndpoint100RedfishSystemInfo ¶

type ComponentEndpoint100RedfishSystemInfo struct {
	// The Redfish 'name' of the ComputerSystem.
	Name            string                           `json:"Name,omitempty"`
	Actions         *Actions100ComputerSystemActions `json:"Actions,omitempty"`
	EthernetNICInfo []EthernetNicInfo100             `json:"EthernetNICInfo,omitempty"`
	// The URL for the power info for this node.
	PowerURL     string            `json:"PowerURL,omitempty"`
	PowerControl []PowerControl100 `json:"PowerControl,omitempty"`
}

This is the SystemInfo object in the RF ComputerSystem subtype of ComponentEndpoint, i.e. when the latter's RedfishType is ComputerSystem. It contains HMS-Node/ComputerSystem-specific Redfish fields that need to be collected during discovery and made available to clients. This is where new fields will be added. Mostly placeholder now.

type ComponentEndpoint100ResourceUriCollection ¶

type ComponentEndpoint100ResourceUriCollection struct {
	// Should describe the collection, though the type of resources the links correspond to should also be inferred from the context in which the collection was obtained.
	Name string `json:"Name,omitempty"`
	// An array of ResourceIds.
	Members []ResourceUri100 `json:"Members,omitempty"`
	// Number of ResourceURIs in the collection
	MemberCount float64 `json:"MemberCount,omitempty"`
}

type ComponentEndpointApiDoComponentEndpointsGetOpts ¶

type ComponentEndpointApiDoComponentEndpointsGetOpts struct {
	Id          optional.String
	RedfishEp   optional.String
	Type_       optional.String
	RedfishType optional.String
}

type ComponentEndpointApiService ¶

type ComponentEndpointApiService service

func (*ComponentEndpointApiService) DoComponentEndpointDelete ¶

func (a *ComponentEndpointApiService) DoComponentEndpointDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

ComponentEndpointApiService Delete ComponentEndpoint with ID {xname} Delete ComponentEndpoint for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of ComponentEndpoint record to delete.

@return Response100

func (*ComponentEndpointApiService) DoComponentEndpointGet ¶

func (a *ComponentEndpointApiService) DoComponentEndpointGet(ctx context.Context, xname string) (ComponentEndpoint100ComponentEndpoint, *http.Response, error)

ComponentEndpointApiService Retrieve ComponentEndpoint at {xname} Retrieve ComponentEndpoint record for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of ComponentEndpoint record to return.

@return ComponentEndpoint100ComponentEndpoint

func (*ComponentEndpointApiService) DoComponentEndpointsDeleteAll ¶

func (a *ComponentEndpointApiService) DoComponentEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

ComponentEndpointApiService Delete all ComponentEndpoints Delete all entries in the ComponentEndpoint collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*ComponentEndpointApiService) DoComponentEndpointsGet ¶

func (a *ComponentEndpointApiService) DoComponentEndpointsGet(ctx context.Context, localVarOptionals *ComponentEndpointApiDoComponentEndpointsGetOpts) (ComponentEndpointArrayComponentEndpointArray, *http.Response, error)

type ComponentEndpointArrayComponentEndpointArray ¶

type ComponentEndpointArrayComponentEndpointArray struct {
	// Contains the HMS RedfishEndpoint objects in the array.
	ComponentEndpoints []ComponentEndpoint100ComponentEndpoint `json:"ComponentEndpoints,omitempty"`
}

This is a collection of ComponentEndpoint objects returned whenever a query is expected to result in 0 to n matches.

type ComponentEndpointArrayPostQuery ¶

type ComponentEndpointArrayPostQuery struct {
	// An array of XName/ID values for the ComponentEndpoints to query.
	ComponentEndpointIDs []string `json:"ComponentEndpointIDs"`
	Partition            string   `json:"partition,omitempty"`
}

There are limits to the length of an HTTP URL and query string. Hence, if we wish to query an arbitrary list of XName/IDs, it will need to be in the body of the request. This object is used for this purpose. It is similar to the analogous GET operation.

type ComponentEndpointChassis ¶

type ComponentEndpointChassis struct {
	ID    string      `json:"ID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// Domain of component FQDN.  Hostname is always ID/xname
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of component on management network if for example the component is a node.
	FQDN           string             `json:"FQDN,omitempty"`
	RedfishType    *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool `json:"Enabled,omitempty"`
	// This is used as a discriminator to determine the additional RF-type- specific data that is kept for a ComponentEndpoint.
	ComponentEndpointType string `json:"ComponentEndpointType"`
	// If the component e.g. a ComputerSystem/Node has a MAC on the management network, i.e. corresponding to the FQDN field's Ethernet interface, this field will be present.  Not the HSN MAC.  Represented as the standard colon-separated 6 byte hex string.
	MACAddr           string `json:"MACAddr,omitempty"`
	UUID              string `json:"UUID,omitempty"`
	OdataID           string `json:"OdataID,omitempty"`
	RedfishEndpointID string `json:"RedfishEndpointID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// Complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL         string                                  `json:"RedfishURL,omitempty"`
	RedfishChassisInfo *ComponentEndpoint100RedfishChassisInfo `json:"RedfishChassisInfo,omitempty"`
}

This is a subtype of ComponentEndpoint for Chassis RF components, i.e. of most HMS components other than nodes and BMCs. This subtype is used when the ComponentEndpoint's ComponentEndpointType is 'ComponentEndpointChassis' via the 'discriminator: ComponentEndpointType' property.

type ComponentEndpointComputerSystem ¶

type ComponentEndpointComputerSystem struct {
	ID    string      `json:"ID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// Domain of component FQDN.  Hostname is always ID/xname
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of component on management network if for example the component is a node.
	FQDN           string             `json:"FQDN,omitempty"`
	RedfishType    *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool `json:"Enabled,omitempty"`
	// This is used as a discriminator to determine the additional RF-type- specific data that is kept for a ComponentEndpoint.
	ComponentEndpointType string `json:"ComponentEndpointType"`
	// If the component e.g. a ComputerSystem/Node has a MAC on the management network, i.e. corresponding to the FQDN field's Ethernet interface, this field will be present.  Not the HSN MAC.  Represented as the standard colon-separated 6 byte hex string.
	MACAddr           string `json:"MACAddr,omitempty"`
	UUID              string `json:"UUID,omitempty"`
	OdataID           string `json:"OdataID,omitempty"`
	RedfishEndpointID string `json:"RedfishEndpointID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// Complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL        string                                 `json:"RedfishURL,omitempty"`
	RedfishSystemInfo *ComponentEndpoint100RedfishSystemInfo `json:"RedfishSystemInfo,omitempty"`
}

This is a subtype of ComponentEndpoint for ComputerSystem RF components, i.e. a node HMS type. This subtype is used when the ComponentEndpoint's ComponentEndpointType is 'ComponentEndpointComputerSystem' via the 'discriminator: ComponentEndpointType' property.

type ComponentEndpointManager ¶

type ComponentEndpointManager struct {
	ID    string      `json:"ID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// Domain of component FQDN.  Hostname is always ID/xname
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of component on management network if for example the component is a node.
	FQDN           string             `json:"FQDN,omitempty"`
	RedfishType    *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool `json:"Enabled,omitempty"`
	// This is used as a discriminator to determine the additional RF-type- specific data that is kept for a ComponentEndpoint.
	ComponentEndpointType string `json:"ComponentEndpointType"`
	// If the component e.g. a ComputerSystem/Node has a MAC on the management network, i.e. corresponding to the FQDN field's Ethernet interface, this field will be present.  Not the HSN MAC.  Represented as the standard colon-separated 6 byte hex string.
	MACAddr           string `json:"MACAddr,omitempty"`
	UUID              string `json:"UUID,omitempty"`
	OdataID           string `json:"OdataID,omitempty"`
	RedfishEndpointID string `json:"RedfishEndpointID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// Complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL         string                                  `json:"RedfishURL,omitempty"`
	RedfishManagerInfo *ComponentEndpoint100RedfishManagerInfo `json:"RedfishManagerInfo,omitempty"`
}

This is a subtype of ComponentEndpoint for Manager RF components, i.e. any BMC type. For example NodeBMC is a Manager, NodeEnclosure is a Chassis RF type. This subtype is used when the ComponentEndpoint's ComponentEndpointType is 'ComponentEndpointManager' via the 'discriminator: ComponentEndpointType' property.

type ComponentEndpointOutlet ¶

type ComponentEndpointOutlet struct {
	ID    string      `json:"ID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// Domain of component FQDN.  Hostname is always ID/xname
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of component on management network if for example the component is a node.
	FQDN           string             `json:"FQDN,omitempty"`
	RedfishType    *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool `json:"Enabled,omitempty"`
	// This is used as a discriminator to determine the additional RF-type- specific data that is kept for a ComponentEndpoint.
	ComponentEndpointType string `json:"ComponentEndpointType"`
	// If the component e.g. a ComputerSystem/Node has a MAC on the management network, i.e. corresponding to the FQDN field's Ethernet interface, this field will be present.  Not the HSN MAC.  Represented as the standard colon-separated 6 byte hex string.
	MACAddr           string `json:"MACAddr,omitempty"`
	UUID              string `json:"UUID,omitempty"`
	OdataID           string `json:"OdataID,omitempty"`
	RedfishEndpointID string `json:"RedfishEndpointID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// Complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL         string                                 `json:"RedfishURL,omitempty"`
	RedfishChassisInfo *ComponentEndpoint100RedfishOutletInfo `json:"RedfishChassisInfo,omitempty"`
}

This is a subtype of ComponentEndpoint for PowerDistribution Outlet RF components. This subtype is used when the ComponentEndpoints ComponentEndpointType is ComponentEndpointOutlet via the discriminator: ComponentEndpointType property.

type ComponentEndpointPowerDistribution ¶

type ComponentEndpointPowerDistribution struct {
	ID    string      `json:"ID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// Domain of component FQDN.  Hostname is always ID/xname
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of component on management network if for example the component is a node.
	FQDN           string             `json:"FQDN,omitempty"`
	RedfishType    *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool `json:"Enabled,omitempty"`
	// This is used as a discriminator to determine the additional RF-type- specific data that is kept for a ComponentEndpoint.
	ComponentEndpointType string `json:"ComponentEndpointType"`
	// If the component e.g. a ComputerSystem/Node has a MAC on the management network, i.e. corresponding to the FQDN field's Ethernet interface, this field will be present.  Not the HSN MAC.  Represented as the standard colon-separated 6 byte hex string.
	MACAddr           string `json:"MACAddr,omitempty"`
	UUID              string `json:"UUID,omitempty"`
	OdataID           string `json:"OdataID,omitempty"`
	RedfishEndpointID string `json:"RedfishEndpointID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// Complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL         string                                            `json:"RedfishURL,omitempty"`
	RedfishChassisInfo *ComponentEndpoint100RedfishPowerDistributionInfo `json:"RedfishChassisInfo,omitempty"`
}

This is a subtype of ComponentEndpoint for PowerDistribution RF components. This subtype is used when the ComponentEndpoints ComponentEndpointType is ComponentEndpointPowerDistribution via the discriminator: ComponentEndpointType property.

type ComponentEthernetInterfacesApiDoCompEthInterfacesGetV2Opts ¶

type ComponentEthernetInterfacesApiDoCompEthInterfacesGetV2Opts struct {
	MACAddress  optional.String
	IPAddress   optional.String
	Network     optional.String
	ComponentID optional.String
	Type_       optional.String
	OlderThan   optional.String
	NewerThan   optional.String
}

type ComponentEthernetInterfacesApiService ¶

type ComponentEthernetInterfacesApiService service

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceDeleteAllV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceDeleteAllV2(ctx context.Context) (Response100, *http.Response, error)

ComponentEthernetInterfacesApiService Clear the component Ethernet interface collection. Delete all component Ethernet interface entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceDeleteV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceDeleteV2(ctx context.Context, ethInterfaceID string) (Response100, *http.Response, error)

ComponentEthernetInterfacesApiService DELETE existing component Ethernet interface with {ethInterfaceID} Delete the given component Ethernet interface with {ethInterfaceID}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param ethInterfaceID The ID of the component Ethernet interface to delete.

@return Response100

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceGetV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceGetV2(ctx context.Context, ethInterfaceID string) (CompEthInterface100, *http.Response, error)

ComponentEthernetInterfacesApiService GET existing component Ethernet interface {ethInterfaceID} Retrieve the component Ethernet interface which was created with the given {ethInterfaceID}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param ethInterfaceID The ID of the component Ethernet interface to return.

@return CompEthInterface100

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressDeleteV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressDeleteV2(ctx context.Context, ethInterfaceID string, ipAddress string) (Response100, *http.Response, error)

ComponentEthernetInterfacesApiService DELETE existing IP address mapping with {ipAddress} from a component Ethernet interface with {ethInterfaceID} Delete the given IP address mapping with {ipAddress} from a component Ethernet interface with {ethInterfaceID}. The 'LastUpdate' field of the component Ethernet interface will be updated\"

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param ethInterfaceID The ID of the component Ethernet interface to delete the IP address from
@param ipAddress The IP address to delete from the component Ethernet interface.

@return Response100

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressPatchV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressPatchV2(ctx context.Context, body CompEthInterface100IpAddressMappingPatch, ethInterfaceID string, ipAddress string) (*http.Response, error)

ComponentEthernetInterfacesApiService UPDATE metadata for existing IP address {ipAddress} in a component Ethernet interface {ethInterfaceID \"To update the network of an IP address in a component Ethernet interface, a PATCH operation can be used. Omitted fields are not updated. The 'LastUpdate' field of the component Ethernet interface will be updated\"

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param ethInterfaceID The ID of the component Ethernet interface with the IP address to patch.
@param ipAddress The IP address to patch from the component Ethernet interface.

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressesGetV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressesGetV2(ctx context.Context, ethInterfaceID string) ([]CompEthInterface100IpAddressMapping, *http.Response, error)

ComponentEthernetInterfacesApiService Retrieve all IP addresses of a component Ethernet interface {ethInterfaceID} Retrieve all IP addresses of a component Ethernet interface {ethInterfaceID}

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param ethInterfaceID The ID of the component Ethernet interface to retrieve the IP addresses of.

@return []CompEthInterface100IpAddressMapping

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressesPostV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfaceIPAddressesPostV2(ctx context.Context, body CompEthInterface100IpAddressMapping, ethInterfaceID string) (ResourceUri100, *http.Response, error)

ComponentEthernetInterfacesApiService CREATE a new IP address mapping in a component Ethernet interface (via POST) Create a new IP address mapping in a component Ethernet interface {ethInterfaceID}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param ethInterfaceID The ID of the component Ethernet interface to add the IP address to.

@return ResourceUri100

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfacePatchV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfacePatchV2(ctx context.Context, body CompEthInterface100Patch, ethInterfaceID string) (*http.Response, error)

ComponentEthernetInterfacesApiService UPDATE metadata for existing component Ethernet interface {ethInterfaceID} To update the IP address, CompID, and/or description of a component Ethernet interface, a PATCH operation can be used. Omitted fields are not updated. The 'LastUpdate' field will be updated if an IP address is provided.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param ethInterfaceID The ID of the component Ethernet interface to update.

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfacePostV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfacePostV2(ctx context.Context, body CompEthInterface100) (ResourceUri100, *http.Response, error)

ComponentEthernetInterfacesApiService CREATE a new component Ethernet interface (via POST) Create a new component Ethernet interface.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return ResourceUri100

func (*ComponentEthernetInterfacesApiService) DoCompEthInterfacesGetV2 ¶

func (a *ComponentEthernetInterfacesApiService) DoCompEthInterfacesGetV2(ctx context.Context, localVarOptionals *ComponentEthernetInterfacesApiDoCompEthInterfacesGetV2Opts) ([]CompEthInterface100, *http.Response, error)

type ComponentStatus100 ¶

type ComponentStatus100 struct {
	ID                  string    `json:"ID,omitempty"`
	Locked              bool      `json:"Locked,omitempty"`
	Reserved            bool      `json:"Reserved,omitempty"`
	CreatedTime         time.Time `json:"CreatedTime,omitempty"`
	ExpirationTime      time.Time `json:"ExpirationTime,omitempty"`
	ReservationDisabled bool      `json:"ReservationDisabled,omitempty"`
}

type Configuration ¶

type Configuration struct {
	BasePath      string            `json:"basePath,omitempty"`
	Host          string            `json:"host,omitempty"`
	Scheme        string            `json:"scheme,omitempty"`
	DefaultHeader map[string]string `json:"defaultHeader,omitempty"`
	UserAgent     string            `json:"userAgent,omitempty"`
	HTTPClient    *http.Client
}

func NewConfiguration ¶

func NewConfiguration() *Configuration

func (*Configuration) AddDefaultHeader ¶

func (c *Configuration) AddDefaultHeader(key string, value string)

type Counts100 ¶

type Counts100 struct {
	Total   int32 `json:"Total,omitempty"`
	Success int32 `json:"Success,omitempty"`
	Failure int32 `json:"Failure,omitempty"`
}

type DeputyKeys100 ¶

type DeputyKeys100 struct {
	DeputyKeys []XnameWithKey100 `json:"DeputyKeys,omitempty"`
}

type Discover100DiscoverInput ¶

type Discover100DiscoverInput struct {
	// An array of XName/ID values for the RedfishEndpoints to discover. If zero-length or omitted, all RedfishEndpoints will be discovered.
	Xnames []string `json:"xnames,omitempty"`
	// Whether to force discovery if there is already a conflicting DiscoveryStatus entry that is either Pending or InProgress. default is false.
	Force bool `json:"force,omitempty"`
}

The POST body for a Discover operation. Note that these fields are optional. The default for the xnames field is to select all RedfishEndpoints. The default for force is false.

type DiscoverApiDoInventoryDiscoverPostOpts ¶

type DiscoverApiDoInventoryDiscoverPostOpts struct {
	Body optional.Interface
}

type DiscoverApiService ¶

type DiscoverApiService service

func (*DiscoverApiService) DoInventoryDiscoverPost ¶

func (a *DiscoverApiService) DoInventoryDiscoverPost(ctx context.Context, localVarOptionals *DiscoverApiDoInventoryDiscoverPostOpts) ([]ResourceUri100, *http.Response, error)

type DiscoveryStatus100Details ¶

type DiscoveryStatus100Details struct {
}

Details accompanying a DiscoveryStatus entry. Optional. Reserved for future use.

type DiscoveryStatus100DiscoveryStatus ¶

type DiscoveryStatus100DiscoveryStatus struct {
	// The ID number of the discover operation.
	ID float64 `json:"ID,omitempty"`
	// Describes the status of the given Discover operation.
	Status string `json:"Status,omitempty"`
	// The time that the Status field was last updated.
	LastUpdateTime time.Time                  `json:"LastUpdateTime,omitempty"`
	Details        *DiscoveryStatus100Details `json:"Details,omitempty"`
}

Returns info on the current status of a discovery operation with the given ID returned when a Discover action is requested.

type DiscoveryStatusApiService ¶

type DiscoveryStatusApiService service

func (*DiscoveryStatusApiService) DoDiscoveryStatusGet ¶

func (a *DiscoveryStatusApiService) DoDiscoveryStatusGet(ctx context.Context, id float64) (DiscoveryStatus100DiscoveryStatus, *http.Response, error)

DiscoveryStatusApiService Retrieve DiscoveryStatus entry matching {id} Retrieve DiscoveryStatus entry with the specific ID.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id Positive integer ID of DiscoveryStatus entry to retrieve

@return DiscoveryStatus100DiscoveryStatus

func (*DiscoveryStatusApiService) DoDiscoveryStatusGetAll ¶

func (a *DiscoveryStatusApiService) DoDiscoveryStatusGetAll(ctx context.Context) ([]DiscoveryStatus100DiscoveryStatus, *http.Response, error)

DiscoveryStatusApiService Retrieve all DiscoveryStatus entries in collection Retrieve all DiscoveryStatus entries as an unnamed array.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return []DiscoveryStatus100DiscoveryStatus

type EthernetNicInfo100 ¶

type EthernetNicInfo100 struct {
	// The Redfish 'Id' field for the interface.
	RedfishId string `json:"RedfishId,omitempty"`
	// This is the relative path to the EthernetInterface via the Redfish entry point. (i.e. the @odata.id field).
	OdataId string `json:"@odata.id,omitempty"`
	// The Redfish 'Description' field for the interface.
	Description string `json:"Description,omitempty"`
	// The Redfish 'FQDN' of the interface.  This may or may not be set and is not necessarily the same as the FQDN of the ComponentEndpoint.
	FQDN string `json:"FQDN,omitempty"`
	// The Redfish 'Hostname field' for the interface.  This may or may not be set and is not necessarily the same as the Hostname of the ComponentEndpoint.
	Hostname string `json:"Hostname,omitempty"`
	// The Redfish 'InterfaceEnabled' field if provided by Redfish, else it will be omitted.
	InterfaceEnabled bool `json:"InterfaceEnabled,omitempty"`
	// The Redfish 'MacAddress' field for the interface.  This should normally be set but is not necessarily the same as the MacAddr of the ComponentEndpoint (as there may be multiple interfaces).
	MACAddress string `json:"MACAddress,omitempty"`
	// The Redfish 'PermanentMacAddress' field for the interface. This may or may not be set and is not necessarily the same as the MacAddr of the ComponentEndpoint (as there may be multiple interfaces).
	PermanentMACAddress string `json:"PermanentMACAddress,omitempty"`
}

This is a summary info for one ordinary Ethernet NIC (i.e. not on HSN). These fields are all passed through from a Redfish EthernetInterface object.

type FailedXnames100 ¶

type FailedXnames100 struct {
	ID string `json:"ID,omitempty"`
	// The key that can be passed to a delegate.
	Reason string `json:"Reason,omitempty"`
}

type GenericSwaggerError ¶

type GenericSwaggerError struct {
	// contains filtered or unexported fields
}

GenericSwaggerError Provides access to the body, error and model on returned errors.

func (GenericSwaggerError) Body ¶

func (e GenericSwaggerError) Body() []byte

Body returns the raw bytes of the response

func (GenericSwaggerError) Error ¶

func (e GenericSwaggerError) Error() string

Error returns non-empty string if there was an error.

func (GenericSwaggerError) Model ¶

func (e GenericSwaggerError) Model() interface{}

Model returns the unpacked model of the error

type Group100 ¶

type Group100 struct {
	Label string `json:"label"`
	// A one-line, user-provided description of the group.
	Description string `json:"description,omitempty"`
	// A free-form array of strings to provide extra organization/filtering. Not to be confused with labels/groups.
	Tags           []string    `json:"tags,omitempty"`
	ExclusiveGroup string      `json:"exclusiveGroup,omitempty"`
	Members        *Members100 `json:"members,omitempty"`
}

A group is an informal, possibly overlapping division of the system that groups components under an administratively chosen label (i.e. group name). Unlike partitions, components can be members of any number of groups.

type Group100Patch ¶

type Group100Patch struct {
	// A one-line, user-provided description of the group.
	Description string `json:"description,omitempty"`
	// A free-form array of strings to provide extra organization/filtering. Not to be confused with labels/groups.
	Tags []string `json:"tags,omitempty"`
}

To update the tags array and/or description, a PATCH operation can be used. If either field is omitted, it will not be updated. NOTE: This cannot be used to completely replace the members list Rather, individual members can be removed or added with the POST/DELETE /members API.

type GroupApiDoGroupGetOpts ¶

type GroupApiDoGroupGetOpts struct {
	Partition optional.String
}

type GroupApiDoGroupMembersGetOpts ¶

type GroupApiDoGroupMembersGetOpts struct {
	Partition optional.String
}

type GroupApiDoGroupsGetOpts ¶

type GroupApiDoGroupsGetOpts struct {
	Group optional.String
	Tag   optional.String
}

type GroupApiService ¶

type GroupApiService service

func (*GroupApiService) DoGroupDelete ¶

func (a *GroupApiService) DoGroupDelete(ctx context.Context, groupLabel string) (Response100, *http.Response, error)

GroupApiService Delete existing group with {group_label} Delete the given group with {group_label}. Any members previously in the group will no longer have the deleted group label associated with them.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param groupLabel Label (i.e. name) of the group to delete.

@return Response100

func (*GroupApiService) DoGroupGet ¶

func (a *GroupApiService) DoGroupGet(ctx context.Context, groupLabel string, localVarOptionals *GroupApiDoGroupGetOpts) (Group100, *http.Response, error)

func (*GroupApiService) DoGroupLabelsGet ¶

func (a *GroupApiService) DoGroupLabelsGet(ctx context.Context) ([]string, *http.Response, error)

GroupApiService Retrieve all existing group labels Retrieve a string array of all group labels (i.e. group names) that currently exist in HSM.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return []string

func (*GroupApiService) DoGroupMemberDelete ¶

func (a *GroupApiService) DoGroupMemberDelete(ctx context.Context, groupLabel string, xnameId string) (Response100, *http.Response, error)

GroupApiService Delete member from existing group Delete component {xname_id} from the members of group {group_label}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param groupLabel Specifies an existing group {group_label} to remove the member from.
@param xnameId Member of {group_label} to remove.

@return Response100

func (*GroupApiService) DoGroupMembersGet ¶

func (a *GroupApiService) DoGroupMembersGet(ctx context.Context, groupLabel string, localVarOptionals *GroupApiDoGroupMembersGetOpts) (Members100, *http.Response, error)

func (*GroupApiService) DoGroupMembersPost ¶

func (a *GroupApiService) DoGroupMembersPost(ctx context.Context, body MemberId, groupLabel string) ([]ResourceUri100, *http.Response, error)

GroupApiService Create new member of existing group (via POST) Create a new member of group {group_label} with the component xname ID provided in the payload. New member should not already exist in the given group.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param groupLabel Specifies an existing group {group_label} to add the new member to.

@return []ResourceUri100

func (*GroupApiService) DoGroupPatch ¶

func (a *GroupApiService) DoGroupPatch(ctx context.Context, body Group100Patch, groupLabel string) (*http.Response, error)

GroupApiService Update metadata for existing group {group_label} To update the tags array and/or description, a PATCH operation can be used. Omitted fields are not updated. This cannot be used to completely replace the members list. Rather, individual members can be removed or added with the POST/DELETE {group_label}/members API below.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param groupLabel Label (i.e. name) of the group to update.

func (*GroupApiService) DoGroupsGet ¶

func (a *GroupApiService) DoGroupsGet(ctx context.Context, localVarOptionals *GroupApiDoGroupsGetOpts) ([]Group100, *http.Response, error)

func (*GroupApiService) DoGroupsPost ¶

func (a *GroupApiService) DoGroupsPost(ctx context.Context, body Group100) ([]ResourceUri100, *http.Response, error)

GroupApiService Create a new group Create a new group identified by the group_label field. Label should be given explicitly, and should not conflict with any existing group, or an error will occur. Note that if the exclusiveGroup field is present, the group is not allowed to add a member that exists under a different group/label where the exclusiveGroup field is the same. This can be used to create groups of groups where a component may only be present in one of the set.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return []ResourceUri100

type HWInventoryApiDoHWInvByLocationQueryGetOpts ¶

type HWInventoryApiDoHWInvByLocationQueryGetOpts struct {
	Type_     optional.String
	Children  optional.Bool
	Parents   optional.Bool
	Partition optional.String
	Format    optional.String
}

type HWInventoryApiService ¶

type HWInventoryApiService service

func (*HWInventoryApiService) DoHWInvByLocationQueryGet ¶

func (a *HWInventoryApiService) DoHWInvByLocationQueryGet(ctx context.Context, xname string, localVarOptionals *HWInventoryApiDoHWInvByLocationQueryGetOpts) (HwInventory100HwInventory, *http.Response, error)

type HWInventoryByFRUApiDoHWInvByFRUGetAllOpts ¶

type HWInventoryByFRUApiDoHWInvByFRUGetAllOpts struct {
	Fruid        optional.String
	Type_        optional.String
	Manufacturer optional.String
	Partnumber   optional.String
	Serialnumber optional.String
}

type HWInventoryByFRUApiService ¶

type HWInventoryByFRUApiService service

func (*HWInventoryByFRUApiService) DoHWInvByFRUDelete ¶

func (a *HWInventoryByFRUApiService) DoHWInvByFRUDelete(ctx context.Context, fruid string) (Response100, *http.Response, error)

HWInventoryByFRUApiService Delete HWInventoryByFRU entry with FRU identifier {fruid} Delete an entry in the HWInventoryByFRU collection. Note that this does not delete the associated HWInventoryByLocation entry if the FRU is currently residing in the system. In fact, if the FRU ID is associated with a HWInventoryByLocation currently, the deletion will fail.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param fruid Locational xname of HWInventoryByFRU record to delete.

@return Response100

func (*HWInventoryByFRUApiService) DoHWInvByFRUDeleteAll ¶

func (a *HWInventoryByFRUApiService) DoHWInvByFRUDeleteAll(ctx context.Context) (Response100, *http.Response, error)

HWInventoryByFRUApiService Delete all HWInventoryByFRU entries Delete all entries in the HWInventoryByFRU collection. Note that this does not delete any associated HWInventoryByLocation entries. Also, if any items are associated with a HWInventoryByLocation, the deletion will fail.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*HWInventoryByFRUApiService) DoHWInvByFRUGet ¶

func (a *HWInventoryByFRUApiService) DoHWInvByFRUGet(ctx context.Context, fruid string) (HwInventory100HwInventoryByFru, *http.Response, error)

HWInventoryByFRUApiService Retrieve HWInventoryByFRU for {fruid} Retrieve HWInventoryByFRU for a specific fruID.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param fruid Global HMS field-replaceable (FRU) identifier (serial number, etc.) of the hardware component to select.

@return HwInventory100HwInventoryByFru

func (*HWInventoryByFRUApiService) DoHWInvByFRUGetAll ¶

func (a *HWInventoryByFRUApiService) DoHWInvByFRUGetAll(ctx context.Context, localVarOptionals *HWInventoryByFRUApiDoHWInvByFRUGetAllOpts) ([]HwInventory100HwInventoryByFru, *http.Response, error)

type HWInventoryByLocationApiDoHWInvByLocationGetAllOpts ¶

type HWInventoryByLocationApiDoHWInvByLocationGetAllOpts struct {
	Id           optional.String
	Type_        optional.String
	Manufacturer optional.String
	Partnumber   optional.String
	Serialnumber optional.String
	Fruid        optional.String
}

type HWInventoryByLocationApiService ¶

type HWInventoryByLocationApiService service

func (*HWInventoryByLocationApiService) DoHWInvByLocationDelete ¶

func (a *HWInventoryByLocationApiService) DoHWInvByLocationDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

HWInventoryByLocationApiService DELETE HWInventoryByLocation entry with ID (location) {xname} Delete HWInventoryByLocation entry for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of HWInventoryByLocation record to delete.

@return Response100

func (*HWInventoryByLocationApiService) DoHWInvByLocationDeleteAll ¶

func (a *HWInventoryByLocationApiService) DoHWInvByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)

HWInventoryByLocationApiService Delete all HWInventoryByLocation entries Delete all entries in the HWInventoryByLocation collection. Note that this does not delete any associated HWInventoryByFRU entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*HWInventoryByLocationApiService) DoHWInvByLocationGet ¶

func (a *HWInventoryByLocationApiService) DoHWInvByLocationGet(ctx context.Context, xname string) (HwInventory100HwInventoryByLocation, *http.Response, error)

HWInventoryByLocationApiService Retrieve HWInventoryByLocation entry at {xname} Retrieve HWInventoryByLocation entries for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of hardware inventory record to return.

@return HwInventory100HwInventoryByLocation

func (*HWInventoryByLocationApiService) DoHWInvByLocationGetAll ¶

func (a *HWInventoryByLocationApiService) DoHWInvByLocationGetAll(ctx context.Context, localVarOptionals *HWInventoryByLocationApiDoHWInvByLocationGetAllOpts) ([]HwInventory100HwInventoryByLocation, *http.Response, error)

func (*HWInventoryByLocationApiService) DoHWInvByLocationPost ¶

func (a *HWInventoryByLocationApiService) DoHWInvByLocationPost(ctx context.Context, body InventoryHardwareBody) (Response100, *http.Response, error)

HWInventoryByLocationApiService Create/Update hardware inventory entries Create/Update hardware inventory entries

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return Response100

type HWInventoryHistoryApiDoHWInvHistByFRUGetOpts ¶

type HWInventoryHistoryApiDoHWInvHistByFRUGetOpts struct {
	Eventtype optional.String
	Starttime optional.String
	Endtime   optional.String
}

type HWInventoryHistoryApiDoHWInvHistByFRUsGetOpts ¶

type HWInventoryHistoryApiDoHWInvHistByFRUsGetOpts struct {
	Fruid     optional.String
	Eventtype optional.String
	Starttime optional.String
	Endtime   optional.String
}

type HWInventoryHistoryApiDoHWInvHistByLocationGetOpts ¶

type HWInventoryHistoryApiDoHWInvHistByLocationGetOpts struct {
	Eventtype optional.String
	Starttime optional.String
	Endtime   optional.String
}

type HWInventoryHistoryApiDoHWInvHistByLocationsGetOpts ¶

type HWInventoryHistoryApiDoHWInvHistByLocationsGetOpts struct {
	Id        optional.String
	Eventtype optional.String
	Starttime optional.String
	Endtime   optional.String
}

type HWInventoryHistoryApiService ¶

type HWInventoryHistoryApiService service

func (*HWInventoryHistoryApiService) DoHWInvHistByFRUDelete ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByFRUDelete(ctx context.Context, fruid string) (Response100, *http.Response, error)

HWInventoryHistoryApiService Delete history for the HWInventoryByFRU entry with FRU identifier {fruid} Delete history for an entry in the HWInventoryByFRU collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param fruid Locational xname of HWInventoryByFRU record to delete history for.

@return Response100

func (*HWInventoryHistoryApiService) DoHWInvHistByFRUGet ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByFRUGet(ctx context.Context, fruid string, localVarOptionals *HWInventoryHistoryApiDoHWInvHistByFRUGetOpts) (HwInventory100HwInventoryHistoryArray, *http.Response, error)

func (*HWInventoryHistoryApiService) DoHWInvHistByFRUsGet ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByFRUsGet(ctx context.Context, localVarOptionals *HWInventoryHistoryApiDoHWInvHistByFRUsGetOpts) (HwInventory100HwInventoryHistoryCollection, *http.Response, error)

func (*HWInventoryHistoryApiService) DoHWInvHistByLocationDelete ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

HWInventoryHistoryApiService DELETE history for the HWInventoryByLocation entry with ID (location) {xname} Delete history for the HWInventoryByLocation entry for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of HWInventoryByLocation record to delete history for.

@return Response100

func (*HWInventoryHistoryApiService) DoHWInvHistByLocationDeleteAll ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationDeleteAll(ctx context.Context) (Response100, *http.Response, error)

HWInventoryHistoryApiService Clear the HWInventory history. Delete all HWInventory history entries. Note that this also deletes history for any associated HWInventoryByFRU entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*HWInventoryHistoryApiService) DoHWInvHistByLocationGet ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationGet(ctx context.Context, xname string, localVarOptionals *HWInventoryHistoryApiDoHWInvHistByLocationGetOpts) (HwInventory100HwInventoryHistoryArray, *http.Response, error)

func (*HWInventoryHistoryApiService) DoHWInvHistByLocationsGet ¶

func (a *HWInventoryHistoryApiService) DoHWInvHistByLocationsGet(ctx context.Context, localVarOptionals *HWInventoryHistoryApiDoHWInvHistByLocationsGetOpts) (HwInventory100HwInventoryHistoryCollection, *http.Response, error)

type HmsArch100 ¶

type HmsArch100 string

HmsArch100 : This is the basic architecture of the component so the proper software can be selected and so on.

const (
	X86_HmsArch100   HmsArch100 = "X86"
	ARM_HmsArch100   HmsArch100 = "ARM"
	OTHER_HmsArch100 HmsArch100 = "Other"
)

List of HMSArch.1.0.0

type HmsClass100 ¶

type HmsClass100 string

HmsClass100 : This is the HSM hardware class of the component.

const (
	RIVER_HmsClass100    HmsClass100 = "River"
	MOUNTAIN_HmsClass100 HmsClass100 = "Mountain"
	HILL_HmsClass100     HmsClass100 = "Hill"
)

List of HMSClass.1.0.0

type HmsFlag100 ¶

type HmsFlag100 string

HmsFlag100 : This property indicates the state flag of the underlying component.

const (
	OK_HmsFlag100      HmsFlag100 = "OK"
	WARNING_HmsFlag100 HmsFlag100 = "Warning"
	ALERT_HmsFlag100   HmsFlag100 = "Alert"
	LOCKED_HmsFlag100  HmsFlag100 = "Locked"
)

List of HMSFlag.1.0.0

type HmsState100 ¶

type HmsState100 string

HmsState100 : This property indicates the state of the underlying component.

const (
	UNKNOWN_HmsState100   HmsState100 = "Unknown"
	EMPTY_HmsState100     HmsState100 = "Empty"
	POPULATED_HmsState100 HmsState100 = "Populated"
	OFF_HmsState100       HmsState100 = "Off"
	ON_HmsState100        HmsState100 = "On"
	STANDBY_HmsState100   HmsState100 = "Standby"
	HALT_HmsState100      HmsState100 = "Halt"
	READY_HmsState100     HmsState100 = "Ready"
)

List of HMSState.1.0.0

type HmsType100 ¶

type HmsType100 string

HmsType100 : This is the HMS component type category. It has a particular xname format and represents the kind of component that can occupy that location. Not to be confused with RedfishType which is Redfish specific and only used when providing Redfish endpoint data from discovery.

const (
	CDU_HmsType100                         HmsType100 = "CDU"
	CABINET_CDU_HmsType100                 HmsType100 = "CabinetCDU"
	CABINET_PDU_HmsType100                 HmsType100 = "CabinetPDU"
	CABINET_PDU_OUTLET_HmsType100          HmsType100 = "CabinetPDUOutlet"
	CABINET_PDU_POWER_CONNECTOR_HmsType100 HmsType100 = "CabinetPDUPowerConnector"
	CABINET_PDU_CONTROLLER_HmsType100      HmsType100 = "CabinetPDUController"
	CABINET_HmsType100                     HmsType100 = "Cabinet"
	CHASSIS_HmsType100                     HmsType100 = "Chassis"
	CHASSIS_BMC_HmsType100                 HmsType100 = "ChassisBMC"
	CMM_RECTIFIER_HmsType100               HmsType100 = "CMMRectifier"
	CMM_FPGA_HmsType100                    HmsType100 = "CMMFpga"
	CEC_HmsType100                         HmsType100 = "CEC"
	COMPUTE_MODULE_HmsType100              HmsType100 = "ComputeModule"
	ROUTER_MODULE_HmsType100               HmsType100 = "RouterModule"
	NODE_BMC_HmsType100                    HmsType100 = "NodeBMC"
	NODE_ENCLOSURE_HmsType100              HmsType100 = "NodeEnclosure"
	NODE_ENCLOSURE_POWER_SUPPLY_HmsType100 HmsType100 = "NodeEnclosurePowerSupply"
	HSN_BOARD_HmsType100                   HmsType100 = "HSNBoard"
	MGMT_SWITCH_HmsType100                 HmsType100 = "MgmtSwitch"
	MGMT_HL_SWITCH_HmsType100              HmsType100 = "MgmtHLSwitch"
	CDU_MGMT_SWITCH_HmsType100             HmsType100 = "CDUMgmtSwitch"
	NODE_HmsType100                        HmsType100 = "Node"
	PROCESSOR_HmsType100                   HmsType100 = "Processor"
	DRIVE_HmsType100                       HmsType100 = "Drive"
	STORAGE_GROUP_HmsType100               HmsType100 = "StorageGroup"
	NODE_NIC_HmsType100                    HmsType100 = "NodeNIC"
	MEMORY_HmsType100                      HmsType100 = "Memory"
	NODE_ACCEL_HmsType100                  HmsType100 = "NodeAccel"
	NODE_ACCEL_RISER_HmsType100            HmsType100 = "NodeAccelRiser"
	NODE_FPGA_HmsType100                   HmsType100 = "NodeFpga"
	HSN_ASIC_HmsType100                    HmsType100 = "HSNAsic"
	ROUTER_FPGA_HmsType100                 HmsType100 = "RouterFpga"
	ROUTER_BMC_HmsType100                  HmsType100 = "RouterBMC"
	HSN_LINK_HmsType100                    HmsType100 = "HSNLink"
	HSN_CONNECTOR_HmsType100               HmsType100 = "HSNConnector"
	INVALID_HmsType100                     HmsType100 = "INVALID"
)

List of HMSType.1.0.0

type HsnInfo100 ¶

type HsnInfo100 struct {
	HSNTopology    int32       `json:"HSNTopology,omitempty"`
	HSNNetworkType *NetType100 `json:"HSNNetworkType,omitempty"`
	// Contains an HSN info entry for each component.
	HSNInfoEntries []HsnInfoEntry100 `json:"HSNInfoEntries,omitempty"`
}

Component to NIC and Network Coordinate Map

type HsnInfoEntry100 ¶

type HsnInfoEntry100 struct {
	ID       string      `json:"ID,omitempty"`
	Type_    *HmsType100 `json:"Type,omitempty"`
	NICAddrs *[]string   `json:"NICAddrs,omitempty"`
	// HSN Coordinates of the components, an integer tuple of a particular length in array form.
	HSNCoords []int32 `json:"HSNCoords,omitempty"`
}

The HSN info for an individual component, e.g. node.

type HwInvByFruCabinet ¶

type HwInvByFruCabinet struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	CabinetFRUInfo       *HwInventory100RedfishChassisFruInfo `json:"CabinetFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType Cabinet. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUCabinet'.

type HwInvByFruChassis ¶

type HwInvByFruChassis struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	ChassisFRUInfo       *HwInventory100RedfishChassisFruInfo `json:"ChassisFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType Chassis. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUChassis'.

type HwInvByFruComputeModule ¶

type HwInvByFruComputeModule struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	ComputeModuleFRUInfo *HwInventory100RedfishChassisFruInfo `json:"ComputeModuleFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType ComputeModule. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUComputeModule'.

type HwInvByFruDrive ¶

type HwInvByFruDrive struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                             `json:"HWInventoryByFRUType"`
	DriveFRUInfo         *HwInventory100RedfishDriveFruInfo `json:"DriveFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType Drive. It represents a disk drive type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUDrive'.

type HwInvByFruMemory ¶

type HwInvByFruMemory struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                              `json:"HWInventoryByFRUType"`
	MemoryFRUInfo        *HwInventory100RedfishMemoryFruInfo `json:"MemoryFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType Memory. It represents a DIMM or other memory module type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByLocMemory'.

type HwInvByFruMgmtHlSwitch ¶

type HwInvByFruMgmtHlSwitch struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	MgmtHLSwitchFRUInfo  *HwInventory100RedfishChassisFruInfo `json:"MgmtHLSwitchFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType MgmtHLSwitch. It represents a high level management switch. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUMgmtHLSwitch'.

type HwInvByFruMgmtSwitch ¶

type HwInvByFruMgmtSwitch struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	MgmtSwitchFRUInfo    *HwInventory100RedfishChassisFruInfo `json:"MgmtSwitchFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType MgmtSwitch. It represents a management switch. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUMgmtSwitch'.

type HwInvByFruNode ¶

type HwInvByFruNode struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                              `json:"HWInventoryByFRUType"`
	NodeFRUInfo          *HwInventory100RedfishSystemFruInfo `json:"NodeFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType Node. It represents a service, compute, or system node. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUNode'.

type HwInvByFruNodeAccel ¶

type HwInvByFruNodeAccel struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                                 `json:"HWInventoryByFRUType"`
	NodeAccelFRUInfo     *HwInventory100RedfishProcessorFruInfo `json:"NodeAccelFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType NodeAccel. It represents a GPU type (e.g. accelerator). It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUNodeAccel'.

type HwInvByFruNodeAccelRiser ¶

type HwInvByFruNodeAccelRiser struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType  string                                      `json:"HWInventoryByFRUType"`
	NodeAccelRiserFRUInfo *HwInventory100RedfishNodeAccelRiserFruInfo `json:"NodeAccelRiserFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType NodeAccelRiser. It represents a GPUSubsystem baseboard type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUNodeAccelRiser'.

type HwInvByFruNodeBmc ¶

type HwInvByFruNodeBmc struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	NodeBMCFRUInfo       *HwInventory100RedfishManagerFruInfo `json:"NodeBMCFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType NodeBMC. It represents a Node BMC type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUNodeBMC'.

type HwInvByFruNodeEnclosure ¶

type HwInvByFruNodeEnclosure struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	NodeEnclosureFRUInfo *HwInventory100RedfishChassisFruInfo `json:"NodeEnclosureFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType NodeEnclosure. It represents a Mountain node card or River rack enclosure. It is NOT the BMC, which is separate and corresponds to a Redfish Manager. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUNodeEnclosure'.

type HwInvByFruNodeEnclosurePowerSupply ¶

type HwInvByFruNodeEnclosurePowerSupply struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType            string                                                `json:"HWInventoryByFRUType"`
	NodeEnclosurePowerSupplyFRUInfo *HwInventory100RedfishNodeEnclosurePowerSupplyFruInfo `json:"NodeEnclosurePowerSupplyFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType NodeEnclosurePowerSupply. It represents a power supply type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUNodeEnclosurePowerSupply'.

type HwInvByFruOutlet ¶

type HwInvByFruOutlet struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                              `json:"HWInventoryByFRUType"`
	OutletFRUInfoFRUInfo *HwInventory100RedfishOutletFruInfo `json:"OutletFRUInfoFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for Outlet HMSTypes, e.g. CabinetPDUPowerConnector. It represents an outlet of a PDU. It is selected via the \"discriminator:\" HWInventoryByFRUType of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUOutlet'.

type HwInvByFruProcessor ¶

type HwInvByFruProcessor struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                                 `json:"HWInventoryByFRUType"`
	ProcessorFRUInfo     *HwInventory100RedfishProcessorFruInfo `json:"ProcessorFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType Processor. It represents a primary CPU type (e.g. non-accelerator). It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUProcessor'.

type HwInvByFruRouterBmc ¶

type HwInvByFruRouterBmc struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	RouterBMCFRUInfo     *HwInventory100RedfishManagerFruInfo `json:"RouterBMCFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType RouterBMC. It represents a Router BMC type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRURouterBMC'.

type HwInvByFruRouterModule ¶

type HwInvByFruRouterModule struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	RouterModuleFRUInfo  *HwInventory100RedfishChassisFruInfo `json:"RouterModuleFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType RouterModule. This is a Mountain switch module. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRURouterModule'.

type HwInvByFrucduMgmtSwitch ¶

type HwInvByFrucduMgmtSwitch struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	CDUMgmtSwitchFRUInfo *HwInventory100RedfishChassisFruInfo `json:"CDUMgmtSwitchFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType CDUMgmtSwitch. It represents a CDU management switch. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUCDUMgmtSwitch'.

type HwInvByFrucmmRectifier ¶

type HwInvByFrucmmRectifier struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                                    `json:"HWInventoryByFRUType"`
	PowerSupplyFRUInfo   *HwInventory100RedfishCmmRectifierFruInfo `json:"PowerSupplyFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType CMMRectifier. It represents a power supply type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUCMMRectifier'.

type HwInvByFruhsnBoard ¶

type HwInvByFruhsnBoard struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                               `json:"HWInventoryByFRUType"`
	HSNBoardFRUInfo      *HwInventory100RedfishChassisFruInfo `json:"HSNBoardFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType HSNBoard. It represents a Mountain switch card or River TOR enclosure. It is NOT the BMC, which is separate and corresponds to a Redfish Manager. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUHSNBoard'.

type HwInvByFruhsnnic ¶

type HwInvByFruhsnnic struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                       `json:"HWInventoryByFRUType"`
	HSNNICFRUInfo        *HwInventory100HsnnicfruInfo `json:"HSNNICFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for HMSType NodeHsnNic. It represents a node HSN NIC type. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUHSNNIC'.

type HwInvByFrupdu ¶

type HwInvByFrupdu struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string                           `json:"HWInventoryByFRUType"`
	PDUFRUInfo           *HwInventory100RedfishPdufruInfo `json:"PDUFRUInfo,omitempty"`
}

This is a subtype of HWInventoryByFRU for PDU HMSTypes, e.g. CabinetPDU. It represents a Redfish PowerDistribution master or slave PDU. It is selected via the 'discriminator: HWInventoryByFRUType' of HWInventoryByFRU when HWInventoryByFRUType is 'HWInvByFRUPDU'.

type HwInvByLocCabinet ¶

type HwInvByLocCabinet struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	CabinetLocationInfo       *HwInventory100RedfishChassisLocationInfo `json:"CabinetLocationInfo,omitempty"`
	// Embedded chassis HWInv object array representing subcomponents (if query is hierarchical).
	Chassis []HwInvByLocChassis `json:"Chassis,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType Cabinet. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocCabinet'.

type HwInvByLocCduMgmtSwitch ¶

type HwInvByLocCduMgmtSwitch struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	CDUMgmtSwitchLocationInfo *HwInventory100RedfishChassisLocationInfo `json:"CDUMgmtSwitchLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType CDUMgmtSwitch. It represents a CDU management switch. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocCDUMgmtSwitch'.

type HwInvByLocChassis ¶

type HwInvByLocChassis struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	ChassisLocationInfo       *HwInventory100RedfishChassisLocationInfo `json:"ChassisLocationInfo,omitempty"`
	// Embedded ComputeModule HWInv object array representing subcomponents of that type (if query is hierarchical).
	ComputeModules []HwInvByLocComputeModule `json:"ComputeModules,omitempty"`
	// Embedded RouterModule HWInv object array representing subcomponents of that type (if query is hierarchical).
	RouterModules []HwInvByLocRouterModule `json:"RouterModules,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType Chassis. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocChassis'.

type HwInvByLocCmmRectifier ¶

type HwInvByLocCmmRectifier struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                         `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru                `json:"PopulatedFRU,omitempty"`
	CMMRectifierLocationInfo  *HwInventory100RedfishCmmRectifierLocationInfo `json:"CMMRectifierLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType CMMRectifier. It represents a power supply. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocCMMRectifier'.

type HwInvByLocComputeModule ¶

type HwInvByLocComputeModule struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	ComputeModuleLocationInfo *HwInventory100RedfishChassisLocationInfo `json:"ComputeModuleLocationInfo,omitempty"`
	// Embedded NodeEnclosure HWInv object array representing subcomponents of that type (if query is hierarchical).
	NodeEnclosures []HwInvByLocNodeEnclosure `json:"NodeEnclosures,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType ComputeModule. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocComputeModule'.

type HwInvByLocDrive ¶

type HwInvByLocDrive struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                  `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru         `json:"PopulatedFRU,omitempty"`
	DriveLocationInfo         *HwInventory100RedfishDriveLocationInfo `json:"DriveLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType Drive. It represents a disk drive. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocDrive'.

type HwInvByLocHsnBoard ¶

type HwInvByLocHsnBoard struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	HSNBoardLocationInfo      *HwInventory100RedfishChassisLocationInfo `json:"HSNBoardLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType HSNBoard. It represents a Mountain switch card or River TOR enclosure. It is NOT the BMC, which is separate and corresponds to a Redfish Manager. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocHSNBoard'.

type HwInvByLocHsnnic ¶

type HwInvByLocHsnnic struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                            `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru   `json:"PopulatedFRU,omitempty"`
	HSNNICLocationInfo        *HwInventory100HsnnicLocationInfo `json:"HSNNICLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType NodeHSNNIC. It represents a NodeHSNNIC. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocHSNNIC'.

type HwInvByLocMemory ¶

type HwInvByLocMemory struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                   `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru          `json:"PopulatedFRU,omitempty"`
	MemoryLocationInfo        *HwInventory100RedfishMemoryLocationInfo `json:"MemoryLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType Memory. It represents a DIMM or other memory module type. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocMemory'.

type HwInvByLocMgmtHlSwitch ¶

type HwInvByLocMgmtHlSwitch struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	MgmtHLSwitchLocationInfo  *HwInventory100RedfishChassisLocationInfo `json:"MgmtHLSwitchLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType MgmtHLSwitch. It represents a high level management switch. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocMgmtHLSwitch'.

type HwInvByLocMgmtSwitch ¶

type HwInvByLocMgmtSwitch struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	MgmtSwitchLocationInfo    *HwInventory100RedfishChassisLocationInfo `json:"MgmtSwitchLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType MgmtSwitch. It represents a management switch. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocMgmtSwitch'.

type HwInvByLocNode ¶

type HwInvByLocNode struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                   `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru          `json:"PopulatedFRU,omitempty"`
	NodeLocationInfo          *HwInventory100RedfishSystemLocationInfo `json:"NodeLocationInfo,omitempty"`
	// Embedded Processor HWInv object array representing subcomponents of that type (this is default for Nodes).
	Processors []HwInvByLocProcessor `json:"Processors,omitempty"`
	// Embedded NodeAccel HWInv object array representing subcomponents of that type (this is default for Nodes).
	NodeAccels []HwInvByLocNodeAccel `json:"NodeAccels,omitempty"`
	// Embedded Drives HWInv object array representing subcomponents of that type (this is default for Nodes).
	Drives []HwInvByLocDrive `json:"Drives,omitempty"`
	// Embedded Memory HWInv object array representing subcomponents of that type (this is default for Nodes).
	Memory []HwInvByLocMemory `json:"Memory,omitempty"`
	// Embedded NodeAccelRiser HWInv object array representing subcomponents of that type (this is default for Nodes).
	NodeAccelRisers []HwInvByLocNodeAccelRiser `json:"NodeAccelRisers,omitempty"`
	// Embedded NodeHsnNIC HWInv object array representing subcomponents of that type (this is default for Nodes).
	NodeHsnNICs []HwInvByLocHsnnic `json:"NodeHsnNICs,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType Node. It represents a service, compute, or system node. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocNode'.

type HwInvByLocNodeAccel ¶

type HwInvByLocNodeAccel struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                      `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru             `json:"PopulatedFRU,omitempty"`
	NodeAccelLocationInfo     *HwInventory100RedfishProcessorLocationInfo `json:"NodeAccelLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType NodeAccel. It represents a GPU type (e.g. accelerator). It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocNodeAccel'.

type HwInvByLocNodeAccelRiser ¶

type HwInvByLocNodeAccelRiser struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType  string                                           `json:"HWInventoryByLocationType"`
	PopulatedFRU               *HwInventory100HwInventoryByFru                  `json:"PopulatedFRU,omitempty"`
	NodeAccelRiserLocationInfo *HwInventory100RedfishNodeAccelRiserLocationInfo `json:"NodeAccelRiserLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType NodeAccelRiser. It represents a GPUSubsystem baseboard. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocNodeAccelRiser'.

type HwInvByLocNodeBmc ¶

type HwInvByLocNodeBmc struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	NodeBMCLocationInfo       *HwInventory100RedfishManagerLocationInfo `json:"NodeBMCLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType NodeBMC. It represents a NodeBMC. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocNodeBMC'.

type HwInvByLocNodeEnclosure ¶

type HwInvByLocNodeEnclosure struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	NodeEnclosureLocationInfo *HwInventory100RedfishChassisLocationInfo `json:"NodeEnclosureLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType NodeEnclosure. It represents a Mountain node card or River rack enclosure. It is NOT the BMC, which is separate and corresponds to a Redfish Manager. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocNodeEnclosure'.

type HwInvByLocNodeEnclosurePowerSupply ¶

type HwInvByLocNodeEnclosurePowerSupply struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType            string                                                     `json:"HWInventoryByLocationType"`
	PopulatedFRU                         *HwInventory100HwInventoryByFru                            `json:"PopulatedFRU,omitempty"`
	NodeEnclosurePowerSupplyLocationInfo *HwInventory100RedfishNodeEnclosurePowerSupplyLocationInfo `json:"NodeEnclosurePowerSupplyLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType NodeEnclosurePowerSupply. It represents a power supply. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocNodeEnclosurePowerSupply'.

type HwInvByLocOutlet ¶

type HwInvByLocOutlet struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                   `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru          `json:"PopulatedFRU,omitempty"`
	OutletLocationInfo        *HwInventory100RedfishOutletLocationInfo `json:"OutletLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType CabinetPDUPowerConnector. It an outlet that is a child of of a parent master or slave PDU. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocOutlet'.

type HwInvByLocPdu ¶

type HwInvByLocPdu struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru       `json:"PopulatedFRU,omitempty"`
	PDULocationInfo           *HwInventory100RedfishPduLocationInfo `json:"PDULocationInfo,omitempty"`
	// Embedded Outlets HWInv object array representing outlets of this PDU.
	CabinetPDUPowerConnectors []HwInvByLocOutlet `json:"CabinetPDUPowerConnectors,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType CabinetPDU. It represents a master or slave PowerDistribution aka PDU component. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocPDU'.

type HwInvByLocProcessor ¶

type HwInvByLocProcessor struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                      `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru             `json:"PopulatedFRU,omitempty"`
	ProcessorLocationInfo     *HwInventory100RedfishProcessorLocationInfo `json:"ProcessorLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType Processor. It represents a primary CPU type (e.g. non-accelerator). It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocProcessor'.

type HwInvByLocRouterBmc ¶

type HwInvByLocRouterBmc struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	RouterBMCLocationInfo     *HwInventory100RedfishManagerLocationInfo `json:"RouterBMCLocationInfo,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType RouterBMC. It represents a RouterBMC. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocRouterBMC'.

type HwInvByLocRouterModule ¶

type HwInvByLocRouterModule struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                                    `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru           `json:"PopulatedFRU,omitempty"`
	RouterModuleLocationInfo  *HwInventory100RedfishChassisLocationInfo `json:"RouterModuleLocationInfo,omitempty"`
	// Embedded HSNBoard HWInv object array representing subcomponents of that type (if query is hierarchical).
	HSNBoards []HwInvByLocHsnBoard `json:"HSNBoards,omitempty"`
}

This is a subtype of HWInventoryByLocation for HMSType RouterModule. This is a Mountain switch module. It is selected via the 'discriminator: HWInventoryByLocationType' of HWInventoryByLocation when HWInventoryByLocationType is 'HWInvByLocRouterModule'.

type HwInventory100HsnnicLocationInfo ¶

type HwInventory100HsnnicLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name.
	Description string `json:"Description,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	Name string `json:"Name,omitempty"`
}

These are pass-through properties of the Node HSN NIC object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100HsnnicfruInfo ¶

type HwInventory100HsnnicfruInfo struct {
	// The manufacturer of this HSN NIC.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// The model of this HSN NIC.
	Model string `json:"Model,omitempty"`
	// The part number for this HSN NIC.
	PartNumber string `json:"PartNumber,omitempty"`
	// The SKU for this HSN NIC.
	SKU string `json:"SKU,omitempty"`
	// The serial number for this HSN NIC.
	SerialNumber string `json:"SerialNumber,omitempty"`
}

These are pass-through properties of the Node HSN NIC type that are also used in HMS inventory data when this is the underlying network object type for a particular HMS component type. These are the properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system.

type HwInventory100HwInventory ¶

type HwInventory100HwInventory struct {
	XName string `json:"XName,omitempty"`
	// How results are displayed   FullyFlat      All component types listed in their own                  arrays only.  No nesting of any children   Hierarchical   All subcomponents listed as children up to                  top level component (or set of cabinets)   NestNodesOnly  Flat except that node subcomponents are nested                  hierarchically. Default is NestNodesOnly.
	Format string `json:"Format,omitempty"`
	// All components with HMS type 'Cabinet' appropriate given Target component/partition and query type.
	Cabinets []HwInvByLocCabinet `json:"Cabinets,omitempty"`
	// All appropriate components with HMS type 'Chassis' given Target component/partition and query type.
	Chassis []HwInvByLocChassis `json:"Chassis,omitempty"`
	// All appropriate components with HMS type 'ComputeModule' given Target component/partition and query type.
	ComputeModules []HwInvByLocComputeModule `json:"ComputeModules,omitempty"`
	// All appropriate components with HMS type 'RouterModule' given Target component/partition and query type.
	RouterModules []HwInvByLocRouterModule `json:"RouterModules,omitempty"`
	// All appropriate components with HMS type 'NodeEnclosure' given Target component/partition and query type.
	NodeEnclosures []HwInvByLocNodeEnclosure `json:"NodeEnclosures,omitempty"`
	// All appropriate components with HMS type 'HSNBoard' given Target component/partition and query type.
	HSNBoards []HwInvByLocHsnBoard `json:"HSNBoards,omitempty"`
	// All appropriate components with HMS type 'MgmtSwitch' given Target component/partition and query type.
	MgmtSwitches []HwInvByLocMgmtSwitch `json:"MgmtSwitches,omitempty"`
	// All appropriate components with HMS type 'MgmtHLSwitch' given Target component/partition and query type.
	MgmtHLSwitches []HwInvByLocMgmtHlSwitch `json:"MgmtHLSwitches,omitempty"`
	// All appropriate components with HMS type 'CDUMgmtSwitch' given Target component/partition and query type.
	CDUMgmtSwitches []HwInvByLocCduMgmtSwitch `json:"CDUMgmtSwitches,omitempty"`
	// All appropriate components with HMS type 'Node' given Target component/partition and query type.
	Nodes []HwInvByLocNode `json:"Nodes,omitempty"`
	// All appropriate components with HMS type 'Processor' given Target component/partition and query type.
	Processors []HwInvByLocProcessor `json:"Processors,omitempty"`
	// All appropriate components with HMS type 'NodeAccel' given Target component/partition and query type.
	NodeAccels []HwInvByLocNodeAccel `json:"NodeAccels,omitempty"`
	// All appropriate components with HMS type 'Drive' given Target component/partition and query type.
	Drives []HwInvByLocDrive `json:"Drives,omitempty"`
	// All appropriate components with HMS type 'Memory' given Target component/partition and query type.
	Memory []HwInvByLocMemory `json:"Memory,omitempty"`
	// All appropriate components with HMS type 'CabinetPDU' given Target component/partition and query type.
	CabinetPDUs []HwInvByLocPdu `json:"CabinetPDUs,omitempty"`
	// All appropriate components with HMS type 'CabinetPDUPowerConnector' given Target component/partition and query type.
	CabinetPDUPowerConnectors []HwInvByLocOutlet `json:"CabinetPDUPowerConnectors,omitempty"`
	// All appropriate components with HMS type 'CMMRectifier' given Target component/partition and query type.
	CMMRectifiers []HwInvByLocCmmRectifier `json:"CMMRectifiers,omitempty"`
	// All appropriate components with HMS type 'NodeAccelRiser' given Target component/partition and query type.
	NodeAccelRisers []HwInvByLocNodeAccelRiser `json:"NodeAccelRisers,omitempty"`
	// All appropriate components with HMS type 'NodeHsnNic' given Target component/partition and query type.
	NodeHsnNICs []HwInvByLocHsnnic `json:"NodeHsnNICs,omitempty"`
	// All appropriate components with HMS type 'NodeEnclosurePowerSupply' given Target component/partition and query type.
	NodeEnclosurePowerSupplies []HwInvByLocNodeEnclosurePowerSupply `json:"NodeEnclosurePowerSupplies,omitempty"`
	// All appropriate components with HMS type 'NodeBMC' given Target component/partition and query type.
	NodeBMC []HwInvByLocNodeBmc `json:"NodeBMC,omitempty"`
	// All appropriate components with HMS type 'RouterBMC' given Target component/partition and query type.
	RouterBMC []HwInvByLocRouterBmc `json:"RouterBMC,omitempty"`
}

This is a collection of hardware inventory data. Depending on the query only some of these arrays will be populated. Also, depending on the query that produced the inventory, some components may have their subcomponents nested underneath them (hierarchical query), rather than all arranged in their own arrays by their types (flat query). The default is hierarchical for node subcomponents (Processors, Memory) and flat for everything else, but other query types are possible and can use this same basic structure. Either way, the 'Target' field is the parent component, partition or system that is used to select the components for the query.

type HwInventory100HwInventoryByFru ¶

type HwInventory100HwInventoryByFru struct {
	FRUID string      `json:"FRUID,omitempty"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// TBD.
	FRUSubtype string `json:"FRUSubtype,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByFRUType string `json:"HWInventoryByFRUType"`

	//   HMSType             Underlying RF Type      How named in json object
	HMSCabinetFRUInfo       *HwInventory100RedfishChassisFruInfo   `json:"CabinetFRUInfo,omitempty"`
	HMSChassisFRUInfo       *HwInventory100RedfishChassisFruInfo   `json:"ChassisFRUInfo,omitempty"` // Mountain chassis
	HMSComputeModuleFRUInfo *HwInventory100RedfishChassisFruInfo   `json:"ComputeModuleFRUInfo,omitempty"`
	HMSRouterModuleFRUInfo  *HwInventory100RedfishChassisFruInfo   `json:"RouterModuleFRUInfo,omitempty"`
	HMSNodeEnclosureFRUInfo *HwInventory100RedfishChassisFruInfo   `json:"NodeEnclosureFRUInfo,omitempty"`
	HMSHSNBoardFRUInfo      *HwInventory100RedfishChassisFruInfo   `json:"HSNBoardFRUInfo,omitempty"`
	HMSMgmtSwitchFRUInfo    *HwInventory100RedfishChassisFruInfo   `json:"MgmtSwitchFRUInfo,omitempty"`
	HMSMgmtHLSwitchFRUInfo  *HwInventory100RedfishChassisFruInfo   `json:"MgmtHLSwitchFRUInfo,omitempty"`
	HMSCDUMgmtSwitchFRUInfo *HwInventory100RedfishChassisFruInfo   `json:"CDUMgmtSwitchFRUInfo,omitempty"`
	HMSNodeFRUInfo          *HwInventory100RedfishSystemFruInfo    `json:"NodeFRUInfo,omitempty"`
	HMSProcessorFRUInfo     *HwInventory100RedfishProcessorFruInfo `json:"ProcessorFRUInfo,omitempty"`
	HMSNodeAccelFRUInfo     *HwInventory100RedfishProcessorFruInfo `json:"NodeAccelFRUInfo,omitempty"`
	HMSMemoryFRUInfo        *HwInventory100RedfishMemoryFruInfo    `json:"MemoryFRUInfo,omitempty"`
	HMSDriveFRUInfo         *HwInventory100RedfishDriveFruInfo     `json:"DriveFRUInfo,omitempty"`

	HMSPDUFRUInfo                      *HwInventory100RedfishPdufruInfo                      `json:"PDUFRUInfo,omitempty"`
	HMSOutletFRUInfo                   *HwInventory100RedfishOutletFruInfo                   `json:"OutletFRUInfo,omitempty"`
	HMSCMMRectifierFRUInfo             *HwInventory100RedfishCmmRectifierFruInfo             `json:"CMMRectifierFRUInfo,omitempty"`
	HMSNodeEnclosurePowerSupplyFRUInfo *HwInventory100RedfishNodeEnclosurePowerSupplyFruInfo `json:"NodeEnclosurePowerSupplyFRUInfo,omitempty"`
	HMSNodeBMCFRUInfo                  *HwInventory100RedfishManagerFruInfo                  `json:"NodeBMCFRUInfo,omitempty"`
	HMSRouterBMCFRUInfo                *HwInventory100RedfishManagerFruInfo                  `json:"RouterBMCFRUInfo,omitempty"`
	HMSNodeAccelRiserFRUInfo           *HwInventory100RedfishNodeAccelRiserFruInfo           `json:"NodeAccelRiserFRUInfo,omitempty"`
}

This represents a physical piece of hardware with properties specific to a unique component in the system. It is the counterpart to HWInventoryByLocation (which contains ONLY information specific to a particular location in the system that may or may not be populated), in that it contains only info about the component that is durably consistent wherever the component is installed in the system (if it is still installed at all).

type HwInventory100HwInventoryByLocation ¶

type HwInventory100HwInventoryByLocation struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is the normalized (from zero) index of the component location (e.g. slot number) when there are more than one.  This should match the last number in the xname in most cases (e.g. Ordinal 0 for node x0c0s0b0n0).  Note that Redfish may use a different value or naming scheme, but this is passed through via the *LocationInfo for the type of component.
	Ordinal int32 `json:"Ordinal,omitempty"`
	// Populated or Empty - whether location is populated.
	Status string `json:"Status,omitempty"`
	// This is used as a discriminator to determine the additional HMS-type specific subtype that is returned.
	HWInventoryByLocationType string                          `json:"HWInventoryByLocationType"`
	PopulatedFRU              *HwInventory100HwInventoryByFru `json:"PopulatedFRU,omitempty"`
}

This is the basic entry in the hardware inventory for a particular location/xname. If the location is populated (e.g. if a slot for a blade exists and the blade is present), then there will also be a link to the FRU entry for the physical piece of hardware that occupies it.

type HwInventory100HwInventoryHistory ¶

type HwInventory100HwInventoryHistory struct {
	ID    string `json:"ID,omitempty"`
	FRUID string `json:"FRUID,omitempty"`
	// The time that the history entry was created.
	Timestamp time.Time `json:"Timestamp,omitempty"`
	// Describes the type of event the history entry was created for.
	EventType string `json:"EventType,omitempty"`
}

This is a HWInventory history entry. Each time a HWInventory event happens a history record is created with associated data including locational xname, FRU ID, timestamp, and event type (Added, Removed, Scanned, etc).

type HwInventory100HwInventoryHistoryArray ¶

type HwInventory100HwInventoryHistoryArray struct {
	// Locational xname or FRU ID of the component associated with the history entries in the 'History' array.
	ID      string                             `json:"ID,omitempty"`
	History []HwInventory100HwInventoryHistory `json:"History,omitempty"`
}

This is the array of history entries for a particular FRU or component location (xname).

type HwInventory100HwInventoryHistoryCollection ¶

type HwInventory100HwInventoryHistoryCollection struct {
	Components []HwInventory100HwInventoryHistoryArray `json:"Components,omitempty"`
}

This is the array of sorted history entries (by FRU or by location).

type HwInventory100RedfishChassisFruInfo ¶

type HwInventory100RedfishChassisFruInfo struct {
	// The administratively-assigned asset tag for this chassis.
	AssetTag string `json:"AssetTag,omitempty"`
	// This property indicates the type of physical form factor of this resource (from Redfish - not all of these will likely appear in practice.  In any case, the HMS type and subtype will identify the hardware type, this is for informational purposes only).
	ChassisType string `json:"ChassisType,omitempty"`
	// Manufacturer-provided model number for part.
	Model string `json:"Model,omitempty"`
	// Intended to provide the manufacturer of the part.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// Manufacturer-provided part number for this component.
	PartNumber string `json:"PartNumber,omitempty"`
	// Manufacturer-provided serial number for this component.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// Manufacturer-provided SKU for this component.
	SKU string `json:"SKU,omitempty"`
}

These are pass-through properties of the Redfish Chassis object type that are also used in HMS inventory data when this is the underlying Redfish object type for a particular HMS component type. These are properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system.

type HwInventory100RedfishChassisLocationInfo ¶

type HwInventory100RedfishChassisLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturer's naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the BMC implementation.
	Description string `json:"Description,omitempty"`
	// This is a pass-through of the Redfish value of the same name. Note this is simply what (if anything) Redfish has been told the hostname is.  It isn't necessarily its hostname on any particular network interface (e.g. the HMS management network).
	Hostname string `json:"Hostname,omitempty"`
}

These are pass-through properties of the Redfish Chassis object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishCmmRectifierFruInfo ¶

type HwInventory100RedfishCmmRectifierFruInfo struct {
	// The manufacturer of this power supply.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// The serial number for this power supply.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// The model number for this power supply.
	Model string `json:"Model,omitempty"`
	// The part number for this power supply.
	PartNumber string `json:"PartNumber,omitempty"`
	// The maximum capacity of this power supply.
	PowerCapacityWatts float64 `json:"PowerCapacityWatts,omitempty"`
	// The measured input power of this power supply.
	PowerInputWatts float64 `json:"PowerInputWatts,omitempty"`
	// The measured output power of this power supply.
	PowerOutputWatts float64 `json:"PowerOutputWatts,omitempty"`
	// The power supply type (AC or DC).
	PowerSupplyType string `json:"PowerSupplyType,omitempty"`
}

These are pass-through properties of the Redfish PowerSupply type that are also used in HMS inventory data when this is the underlying Redfish object type for a particular HMS component type. These are the properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system. Child of a Chassis.

type HwInventory100RedfishCmmRectifierLocationInfo ¶

type HwInventory100RedfishCmmRectifierLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	FirmwareVersion string `json:"FirmwareVersion,omitempty"`
}

These are pass-through properties of the Redfish Power Supply object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishDriveFruInfo ¶

type HwInventory100RedfishDriveFruInfo struct {
	// The drive manufacturer
	Manufacturer string `json:"Manufacturer,omitempty"`
	// Unique identifier
	SerialNumber string `json:"SerialNumber,omitempty"`
	// Manufacturer part number
	PartNumber string `json:"PartNumber,omitempty"`
	// Manufacturer model name
	Model string `json:"Model,omitempty"`
	// Manufacturer Stock Keeping Unit
	SKU string `json:"SKU,omitempty"`
	// Manufacturer Stock Keeping Unit
	CapacityBytes float64 `json:"CapacityBytes,omitempty"`
	// The protocol that this drive currently uses to communicate to the storage controller.
	Protocol string `json:"Protocol,omitempty"`
	// The type of media contained in this drive
	MediaType string `json:"MediaType,omitempty"`
	// The rotation speed of this drive, in revolutions per minute (RPM)
	RotationSpeedRPM float64 `json:"RotationSpeedRPM,omitempty"`
	// The size, in bytes, of the smallest addressable unit, or block
	BlockSizeBytes int32 `json:"BlockSizeBytes,omitempty"`
	// The speed, in gigabit per second (Gbit/s), at which this drive can communicate to a storage controller in ideal conditions.
	CapableSpeedGbs float64 `json:"CapableSpeedGbs,omitempty"`
	// An indication of whether this drive currently predicts a failure in the near future.
	FailurePredicted bool `json:"FailurePredicted,omitempty"`
	// The encryption ability of this drive.
	EncryptionAbility string `json:"EncryptionAbility,omitempty"`
	// The status of the encryption of this drive.
	EncryptionStatus string `json:"EncryptionStatus,omitempty"`
	// The speed, in gigabit per second (Gbit/s), at which this drive currently communicates to the storage controller.
	NegotiatedSpeedGbs float64 `json:"NegotiatedSpeedGbs,omitempty"`
	// The percentage of reads and writes that are predicted to still be available for the media.
	PredictedMediaLifeLeftPercent float64 `json:"PredictedMediaLifeLeftPercent,omitempty"`
}

These are pass-through properties of the Redfish Drive object type that are also used in HMS inventory data. These are properties of a specific drive instance that remain the same if it is relocated within the system.

type HwInventory100RedfishDriveLocationInfo ¶

type HwInventory100RedfishDriveLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturer's naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the BMC implementation.
	Description string `json:"Description,omitempty"`
}

These are pass-through properties of the Redfish Drive object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishManagerFruInfo ¶

type HwInventory100RedfishManagerFruInfo struct {
	// The type of manager that this Resource represents, i.e. BMC, EnclosureManager, RackManager, etc.
	ManagerType string `json:"ManagerType,omitempty"`
	// The manufacturer of this manager.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// The serial number for this manager.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// The model number for this manager.
	Model string `json:"Model,omitempty"`
	// The part number for this manager.
	PartNumber string `json:"PartNumber,omitempty"`
}

These are pass-through properties of the Redfish Manager type that are also used in HMS inventory data when this is the underlying Redfish object type for a particular HMS component type. These are the properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system.

type HwInventory100RedfishManagerLocationInfo ¶

type HwInventory100RedfishManagerLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The current date and time with UTC offset that the manager uses to set or read time.
	DateTime string `json:"DateTime,omitempty"`
	// This is a pass-through of the Redfish value of the same name. The time offset from UTC that the DateTime property is in +HH:MM format.
	DateTimeLocalOffset string `json:"DateTimeLocalOffset,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the implementation.
	Description string `json:"Description,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	FirmwareVersion string `json:"FirmwareVersion,omitempty"`
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturers naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
}

These are pass-through properties of the Redfish Manager object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishMemoryFruInfo ¶

type HwInventory100RedfishMemoryFruInfo struct {
	// The base module type of Memory.
	BaseModuleType string `json:"BaseModuleType,omitempty"`
	// Bus width in bits.
	BusWidthBits float64 `json:"BusWidthBits,omitempty"`
	// Memory Capacity in MiB.
	CapacityMiB float64 `json:"CapacityMiB,omitempty"`
	// Data width in bits.
	DataWidthBits float64 `json:"DataWidthBits,omitempty"`
	// Whether single or multiple errors, or address parity errors can be corrected.
	ErrorCorrection string `json:"ErrorCorrection,omitempty"`
	// The manufacturer of the memory module
	Manufacturer string `json:"Manufacturer,omitempty"`
	// Type of memory module.
	MemoryType string `json:"MemoryType,omitempty"`
	// Type details of the memory.
	MemoryDeviceType string `json:"MemoryDeviceType,omitempty"`
	// Operating speed of Memory in MHz.
	OperatingSpeedMhz float64 `json:"OperatingSpeedMhz,omitempty"`
	// Manufacturer-provided part number for this component.
	PartNumber string `json:"PartNumber,omitempty"`
	// Number of ranks available in the memory.
	RankCount float64 `json:"RankCount,omitempty"`
	// Manufacturer-provided serial number for this component.
	SerialNumber string `json:"SerialNumber,omitempty"`
}

These are pass-through properties of the Redfish Memory object type that are also used in HMS inventory data. These are properties of a specific memory module that remain the same if it the module is relocated within the system.

type HwInventory100RedfishMemoryLocationInfo ¶

type HwInventory100RedfishMemoryLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturer's naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the BMC implementation.
	Description    string                                                 `json:"Description,omitempty"`
	MemoryLocation *HwInventory100RedfishMemoryLocationInfoMemoryLocation `json:"MemoryLocation,omitempty"`
}

These are pass-through properties of the Redfish Memory object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishMemoryLocationInfoMemoryLocation ¶

type HwInventory100RedfishMemoryLocationInfoMemoryLocation struct {
	// Socket number (numbering may vary by manufacturer).
	Socket float64 `json:"Socket,omitempty"`
	// Memory controller number (numbering may vary by manufacturer).
	MemoryController float64 `json:"MemoryController,omitempty"`
	// Channel number (numbering may vary by manufacturer).
	Channel float64 `json:"Channel,omitempty"`
	// Slot number (numbering may vary by manufacturer).
	Slot float64 `json:"Slot,omitempty"`
}

Describes the location of the memory module. Note that the indexing of these fields are set by the manufacturer and may not start at zero (or one for that matter) and therefore are for informational/servicing purposes only. This object and its fields are again a pass-through from Redfish.

type HwInventory100RedfishNodeAccelRiserFruInfo ¶

type HwInventory100RedfishNodeAccelRiserFruInfo struct {
	// The manufacturer of this riser card.
	Producer string `json:"Producer,omitempty"`
	// The serial number for this riser card.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// The model number for this riser card.
	Model string `json:"Model,omitempty"`
	// The part number for this riser card.
	PartNumber string `json:"PartNumber,omitempty"`
	// The date of production of this riser card.
	ProductionDate string `json:"ProductionDate,omitempty"`
	// The version of this riser card.
	Version string `json:"Version,omitempty"`
	// The engineering change level of this riser card.
	EngineeringChangeLevel string `json:"EngineeringChangeLevel,omitempty"`
	// The hardware type of this riser card.
	PhysicalContext string `json:"PhysicalContext,omitempty"`
}

These are the properties of the NodeAccelRiser type that are passed-through to the HMS inventory data when the underlying Redfish object type is an Assembly with a PhysicalContext of GPUSubsystem. These are the properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system. Child of a Chassis.

type HwInventory100RedfishNodeAccelRiserLocationInfo ¶

type HwInventory100RedfishNodeAccelRiserLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	Description string `json:"Description,omitempty"`
}

These are the properties of the NodeAccelRiser type that are passed-through to the HMS inventory data when the underlying Redfish object type is an Assembly with a PhysicalContext of GPUSubsystem. These are the properties of a specific hardware instance/FRU that may change if the component is relocated within the system. Child of a Chassis.

type HwInventory100RedfishNodeEnclosurePowerSupplyFruInfo ¶

type HwInventory100RedfishNodeEnclosurePowerSupplyFruInfo struct {
	// The manufacturer of this power supply.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// The serial number for this power supply.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// The model number for this power supply.
	Model string `json:"Model,omitempty"`
	// The part number for this power supply.
	PartNumber string `json:"PartNumber,omitempty"`
	// The maximum capacity of this power supply.
	PowerCapacityWatts float64 `json:"PowerCapacityWatts,omitempty"`
	// The measured input power of this power supply.
	PowerInputWatts float64 `json:"PowerInputWatts,omitempty"`
	// The measured output power of this power supply.
	PowerOutputWatts float64 `json:"PowerOutputWatts,omitempty"`
	// The power supply type (AC or DC).
	PowerSupplyType string `json:"PowerSupplyType,omitempty"`
}

These are pass-through properties of the Redfish PowerSupply type that are also used in HMS inventory data when this is the underlying Redfish object type for a particular HMS component type. These are the properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system. Child of a Chassis.

type HwInventory100RedfishNodeEnclosurePowerSupplyLocationInfo ¶

type HwInventory100RedfishNodeEnclosurePowerSupplyLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	FirmwareVersion string `json:"FirmwareVersion,omitempty"`
}

These are pass-through properties of the Redfish Power Supply object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishOutletFruInfo ¶

type HwInventory100RedfishOutletFruInfo struct {
	// type of voltage
	VoltageType string `json:"VoltageType,omitempty"`
	// Nominal voltage for outlet.
	NominalVoltage string `json:"NominalVoltage,omitempty"`
	// Indicates if the outlet can be powered.
	PowerEnabled bool `json:"PowerEnabled,omitempty"`
	// Rated current in amps
	RatedCurrentAmps float64 `json:"RatedCurrentAmps,omitempty"`
	// Type of outlet.
	OutletType string `json:"OutletType,omitempty"`
	// Phase wiring type
	PhaseWiringType string `json:"PhaseWiringType,omitempty"`
}

These are pass-through properties of the Redfish Outlet type that are also used in HMS inventory data when this is the underlying Redfish object type for a particular HMS component type. These are the properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system. Child of a PDU.

type HwInventory100RedfishOutletLocationInfo ¶

type HwInventory100RedfishOutletLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturers naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the implementation.
	Description string `json:"Description,omitempty"`
}

These are pass-through properties of the Redfish PDU Outlet object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishPduLocationInfo ¶

type HwInventory100RedfishPduLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturers naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the implementation.
	Description string `json:"Description,omitempty"`
	// This is a pass-through of the Redfish value of the same name.
	UUID string `json:"UUID,omitempty"`
}

These are pass-through properties of the Redfish PowerDistribution object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishPdufruInfo ¶

type HwInventory100RedfishPdufruInfo struct {
	// The administratively-assigned asset tag for this chassis.
	AssetTag string `json:"AssetTag,omitempty"`
	// Manufacturer-provided date-of-manufacture for part.
	DateOfManufacture string `json:"DateOfManufacture,omitempty"`
	// This property indicates the type of PowerDistribution in practice.  In any case, the HMS type and subtype will identify the hardware type, this is for informational purposes only).
	EquipmentType string `json:"EquipmentType,omitempty"`
	// Firmware version at time of discovery.
	FirmwareVersion string `json:"FirmwareVersion,omitempty"`
	// Manufacturer-provided HardwareRevision for part.
	HardwareRevision string `json:"HardwareRevision,omitempty"`
	// Manufacturer-provided model number for part.
	Model string `json:"Model,omitempty"`
	// Intended to provide the manufacturer of the part.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// Manufacturer-provided part number for this component.
	PartNumber string `json:"PartNumber,omitempty"`
	// Manufacturer-provided serial number for this component.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// Manufacturer-provided SKU for this component.
	SKU            string                                         `json:"SKU,omitempty"`
	CircuitSummary *HwInventory100RedfishPdufruInfoCircuitSummary `json:"CircuitSummary,omitempty"`
}

These are pass-through properties of the Redfish PowerDistribution type that are also used in HMS inventory data when this is the underlying Redfish object type for a particular HMS component type. These are properties of a specific hardware instance/FRU that remain the same if the component is relocated within the system.

type HwInventory100RedfishPdufruInfoCircuitSummary ¶

type HwInventory100RedfishPdufruInfoCircuitSummary struct {
	// Number of monitored outlets
	MonitoredOutlets float64 `json:"MonitoredOutlets,omitempty"`
	// Number of phases in total
	TotalPhases float64 `json:"TotalPhases,omitempty"`
	// Total number of controller outlets
	ControlledOutlets float64 `json:"ControlledOutlets,omitempty"`
	// Total number of outlets
	TotalOutlets float64 `json:"TotalOutlets,omitempty"`
	// Number of monitored branches
	MonitoredBranches float64 `json:"MonitoredBranches,omitempty"`
	// Number of monitored phases
	MonitoredPhases float64 `json:"MonitoredPhases,omitempty"`
	// Number of total branches.
	TotalBranches float64 `json:"TotalBranches,omitempty"`
}

Summary of circuits for PDU.

type HwInventory100RedfishProcessorFruInfo ¶

type HwInventory100RedfishProcessorFruInfo struct {
	// The instruction set of the processor (Redfish pass-through)
	InstructionSet string `json:"InstructionSet,omitempty"`
	// The processor manufacturer
	Manufacturer string `json:"Manufacturer,omitempty"`
	// The maximum clock speed of the processor
	MaxSpeedMHz float64 `json:"MaxSpeedMHz,omitempty"`
	// The product model number of this device
	Model string `json:"Model,omitempty"`
	// The architecture of the processor
	ProcessorArchitecture string                                            `json:"ProcessorArchitecture,omitempty"`
	ProcessorId           *HwInventory100RedfishProcessorFruInfoProcessorId `json:"ProcessorId,omitempty"`
	// The type of processor
	ProcessorType string `json:"ProcessorType,omitempty"`
	// The total number of cores contained in this processor
	TotalCores float64 `json:"TotalCores,omitempty"`
	// The total number of execution threads supported by this processor
	TotalThreads float64 `json:"TotalThreads,omitempty"`
}

These are pass-through properties of the Redfish Processor object type that are also used in HMS inventory data. These are properties of a specific processor instance that remain the same if it is relocated within the system.

type HwInventory100RedfishProcessorFruInfoProcessorId ¶

type HwInventory100RedfishProcessorFruInfoProcessorId struct {
	// The effective Family for this processor
	EffectiveFamily string `json:"EffectiveFamily,omitempty"`
	// The effective Model for this processor
	EffectiveModel string `json:"EffectiveModel,omitempty"`
	// The contents of the Identification Registers (CPUID) for this processor
	IdentificationRegisters string `json:"IdentificationRegisters,omitempty"`
	// The Microcode Information for this processor
	MicrocodeInfo string `json:"MicrocodeInfo,omitempty"`
	// The Step value for this processor
	Step string `json:"Step,omitempty"`
	// The Vendor Identification for this processor
	VendorId string `json:"VendorId,omitempty"`
}

Identification information for this processor. Pass-through from Redfish.

type HwInventory100RedfishProcessorLocationInfo ¶

type HwInventory100RedfishProcessorLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturer's naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the BMC implementation.
	Description string `json:"Description,omitempty"`
	// This is a pass-through of the Redfish value of the same name. It represents the socket or location of the processor, and may differ from the normalized HMS Ordinal value (or xname) that is always indexed from 0.  Manufacturers may or may not use zero indexing (or may have some other naming scheme for sockets) and so we retain this information to resolve any ambiguity when servicing the component.
	Socket string `json:"Socket,omitempty"`
}

These are pass-through properties of the Redfish Processor object type that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishSystemFruInfo ¶

type HwInventory100RedfishSystemFruInfo struct {
	// The administratively-assigned asset tag for this chassis.
	AssetTag string `json:"AssetTag,omitempty"`
	// The version of the system BIOS or primary system firmware.
	BiosVersion string `json:"BiosVersion,omitempty"`
	// Manufacturer-provided model number for part.
	Model string `json:"Model,omitempty"`
	// Intended to provide the manufacturer of the part.
	Manufacturer string `json:"Manufacturer,omitempty"`
	// Manufacturer-provided part number for this component.
	PartNumber string `json:"PartNumber,omitempty"`
	// Manufacturer-provided serial number for this component.
	SerialNumber string `json:"SerialNumber,omitempty"`
	// Manufacturer-provided SKU for this component.
	SKU string `json:"SKU,omitempty"`
	// Type of system.  Probably always physical for now.
	SystemType string `json:"SystemType,omitempty"`
	UUID       string `json:"UUID,omitempty"`
}

These are pass-through properties of the Redfish ComputerSystem object that are also used in HMS inventory data. These are properties of a specific hardware instance that remain the same if the component is relocated within the system. Note that Redfish ComputerSystem objects are an abstract type that represents a system, but not necessarily a specific piece of hardware. Chassis objects represent things like the physical enclosure. The system links to chassis and also to subcomponents that have their own object types like Processors, Memory, and Storage. That said, they are a close fit to how we represent nodes in HMS and so it makes sense to pass through their properties since that is how we will discover this information anyways.

type HwInventory100RedfishSystemLocationInfo ¶

type HwInventory100RedfishSystemLocationInfo struct {
	// This is a pass-through of the Redfish value of the same name. The Id is included for informational purposes.  The RedfishEndpoint objects are intended to help locate and interact with HMS components via the Redfish endpoint, so this is mostly needed in case servicing the component requires its ID/name according to a particular COTS manufacturer's naming scheme within, for example, a particular server enclosure.
	Id string `json:"Id,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is included for informational purposes as the naming will likely vary from manufacturer-to-manufacturer, but should help match items up to manufacturer's documentation if the normalized HMS naming scheme is too vague for some COTS systems.
	Name string `json:"Name,omitempty"`
	// This is a pass-through of the Redfish value of the same name. This is an informational description set by the BMC implementation.
	Description string `json:"Description,omitempty"`
	// This is a pass-through of the Redfish value of the same name. Note this is simply what (if anything) Redfish has been told the hostname is.  It isn't necessarily its hostname on any particular network interface (e.g. the HMS management network).
	Hostname         string                                                   `json:"Hostname,omitempty"`
	ProcessorSummary *HwInventory100RedfishSystemLocationInfoProcessorSummary `json:"ProcessorSummary,omitempty"`
	MemorySummary    *HwInventory100RedfishSystemLocationInfoMemorySummary    `json:"MemorySummary,omitempty"`
}

These are pass-through properties of the Redfish ComputerSystem object that are also used in HMS inventory data. They will be mostly informational as exactly how fields are set depends on how the particular implementation does things, but will be useful for servicing.

type HwInventory100RedfishSystemLocationInfoMemorySummary ¶

type HwInventory100RedfishSystemLocationInfoMemorySummary struct {
	// The total installed, operating system-accessible memory (RAM), measured in GiB.
	TotalSystemMemoryGiB float64 `json:"TotalSystemMemoryGiB,omitempty"`
}

This object describes the memory of the system in general detail. It is taken from ComputerSystem.1.0.0_MemorySummary.

type HwInventory100RedfishSystemLocationInfoProcessorSummary ¶

type HwInventory100RedfishSystemLocationInfoProcessorSummary struct {
	// The number of processors in the system.
	Count float64 `json:"Count,omitempty"`
	// The processor model for the primary or majority of processors in this system.
	Model string `json:"Model,omitempty"`
}

This is a summary of the installed processors, if any. It is taken from ComputerSystem.1.0.0_ProcessorSummary.

type InventoryHardwareBody ¶

type InventoryHardwareBody struct {
	Hardware []HwInventory100HwInventoryByLocation `json:"Hardware,omitempty"`
}

type Lock100 ¶

type Lock100 struct {
	// The ID number of the lock.
	Id string `json:"id,omitempty"`
	// A timestamp for when the lock was created.
	Created time.Time `json:"created,omitempty"`
	// A one-line, user-provided reason for the lock.
	Reason string `json:"reason,omitempty"`
	// A user-provided self identifier for the lock
	Owner string `json:"owner"`
	// The length of time in seconds the component lock should exist before it is automatically deleted by HSM.
	Lifetime int32 `json:"lifetime"`
	// An array of XName/ID values for the components managed by the lock. These components will have their component flag set to \"Locked\" upon lock creation and set to \"OK\" upon lock deletion.
	Xnames []string `json:"xnames"`
}

A lock is an object describing a temporary reservation of a set of components held by an external service. If not removed by the external service, HSM will automatically remove the lock after its lifetime has expired.

type Lock100Patch ¶

type Lock100Patch struct {
	// A one-line, user-provided reason for the lock.
	Reason string `json:"reason,omitempty"`
	// A user-provided self identifier for the lock (service.JobID)
	Owner string `json:"owner,omitempty"`
	// The length of time in seconds the component lock should exist before it is automatically deleted by HSM.
	Lifetime int32 `json:"lifetime,omitempty"`
}

To update the reason, owner, and/or lifetime fields, a PATCH operation can be used. Omitted fields are not updated. NOTE: Updating the lifetime field renews the lock. The new expiration time is the lifetime length AFTER the update. The creation timestamp is updated.

type LockingApiLocksStatusGetOpts ¶

type LockingApiLocksStatusGetOpts struct {
	Type_               optional.String
	State               optional.String
	Role                optional.String
	Subrole             optional.String
	Locked              optional.Bool
	Reserved            optional.Bool
	ReservationDisabled optional.Bool
}

type LockingApiService ¶

type LockingApiService service

func (*LockingApiService) LocksDisablePost ¶

func (a *LockingApiService) LocksDisablePost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

LockingApiService Disables the ability to create a reservation on components. Disables the ability to create a reservation on components, deletes any existing reservations. Does not change lock state. Attempting to disable an already-disabled component will not result in an error.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to disable.

@return XnameResponse100

func (*LockingApiService) LocksLockPost ¶

func (a *LockingApiService) LocksLockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

LockingApiService Locks components. Using a component create a lock. Cannot be locked if already locked, or if there is a current reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to lock.

@return XnameResponse100

func (*LockingApiService) LocksRepairPost ¶

func (a *LockingApiService) LocksRepairPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

LockingApiService Repair components lock and reservation ability. Repairs the disabled status of an xname allowing new reservations to be created.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to repair.

@return XnameResponse100

func (*LockingApiService) LocksReservationsPost ¶

func (a *LockingApiService) LocksReservationsPost(ctx context.Context, body AdminReservationCreate100) (AdminReservationCreateResponse100, *http.Response, error)

LockingApiService Create reservations Creates reservations on a set of xnames of infinite duration. Component must be locked to create a reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to create reservations. A `rigid` processing model will result in the entire set of xnames not having reservations created if an xname doesn't exist, or isn't locked, or if already reserved. A `flexible` processing model will perform all actions possible.

@return AdminReservationCreateResponse100

func (*LockingApiService) LocksReservationsReleasePost ¶

func (a *LockingApiService) LocksReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)

LockingApiService Releases existing reservations. Given a list of {xname & reservation key}, releases the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to release reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation released if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*LockingApiService) LocksReservationsRemovePost ¶

func (a *LockingApiService) LocksReservationsRemovePost(ctx context.Context, body AdminReservationRemove100) (XnameResponse100, *http.Response, error)

LockingApiService Forcibly deletes existing reservations. Given a list of components, forcibly deletes any existing reservation. Does not change lock state; does not disable the reservation ability of the component. An empty set of xnames will delete reservations on all xnames. This functionality should be used sparingly, the normal flow should be to release reservations, versus removing them.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to remove reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation removed if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*LockingApiService) LocksServiceReservationsCheckPost ¶

func (a *LockingApiService) LocksServiceReservationsCheckPost(ctx context.Context, body DeputyKeys100) (ServiceReservationCheckResponse100, *http.Response, error)

LockingApiService Check the validity of reservations. Using xname + reservation key check on the validity of reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components & deputy keys to check on validity of reservations.

@return ServiceReservationCheckResponse100

func (*LockingApiService) LocksServiceReservationsPost ¶

func (a *LockingApiService) LocksServiceReservationsPost(ctx context.Context, body ServiceReservationCreate100) (ServiceReservationCreateResponse100, *http.Response, error)

LockingApiService Create reservations Creates reservations on a set of xnames of finite duration. Component must be unlocked to create a reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to create reservations. A `rigid` processing model will result in the entire set of xnames not having reservations created if an xname doesn't exist, or isn't locked, or if already reserved. A `flexible` processing model will perform all actions possible.

@return ServiceReservationCreateResponse100

func (*LockingApiService) LocksServiceReservationsReleasePost ¶

func (a *LockingApiService) LocksServiceReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)

LockingApiService Releases existing reservations. Given a list of {xname & reservation key}, releases the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to release reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation released if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*LockingApiService) LocksServiceReservationsRenewPost ¶

func (a *LockingApiService) LocksServiceReservationsRenewPost(ctx context.Context, body ReservedKeysWithRenewal100) (XnameResponse100, *http.Response, error)

LockingApiService Renew existing reservations. Given a list of {xname & reservation key}, renews the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to renew reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation renewed if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*LockingApiService) LocksStatusGet ¶

func (a *LockingApiService) LocksStatusGet(ctx context.Context, localVarOptionals *LockingApiLocksStatusGetOpts) (AdminStatusCheckResponse100, *http.Response, error)

func (*LockingApiService) LocksStatusPost ¶

func (a *LockingApiService) LocksStatusPost(ctx context.Context, body Xnames) (AdminStatusCheckResponse100, *http.Response, error)

LockingApiService Retrieve lock status for component IDs. Using component ID retrieve the status of any lock and/or reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to retrieve status.

@return AdminStatusCheckResponse100

func (*LockingApiService) LocksUnlockPost ¶

func (a *LockingApiService) LocksUnlockPost(ctx context.Context, body AdminLock100) (XnameResponse100, *http.Response, error)

LockingApiService Unlocks components. Using a component unlock a lock. Cannot be unlocked if already unlocked.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of xnames to unlock.

@return XnameResponse100

type MemberId ¶

type MemberId struct {
	Id string `json:"id,omitempty"`
}

This is used when creating an new entry in a Group or Partition members array. It is the xname ID of the new member.

type Members100 ¶

type Members100 struct {
	// Set of Component XName IDs that represent the membership of the group or partition.
	Ids []string `json:"ids,omitempty"`
}

The members are a fully enumerated (i.e. no implied members besides those explicitly provided) representation of the components a partition or group

type Membership100 ¶

type Membership100 struct {
	Id string `json:"id,omitempty"`
	// The name is a human-readable identifier for the partition and uniquely identifies it.
	PartitionName string `json:"partitionName,omitempty"`
	// An array with all group labels the component is associated with The label is the human-readable identifier for a group and uniquely identifies it.
	GroupLabels []string `json:"groupLabels,omitempty"`
}

A membership is a mapping of a component xname to its set of group labels and partition names.

type MembershipApiDoMembershipsGetOpts ¶

type MembershipApiDoMembershipsGetOpts struct {
	Id             optional.String
	Type_          optional.String
	State          optional.String
	Flag           optional.String
	Role           optional.String
	Subrole        optional.String
	Enabled        optional.String
	Softwarestatus optional.String
	Subtype        optional.String
	Arch           optional.String
	Class          optional.String
	Nid            optional.String
	NidStart       optional.String
	NidEnd         optional.String
	Partition      optional.String
	Group          optional.String
}

type MembershipApiService ¶

type MembershipApiService service

func (*MembershipApiService) DoMembershipGet ¶

func (a *MembershipApiService) DoMembershipGet(ctx context.Context, xname string) (Membership100, *http.Response, error)

MembershipApiService Retrieve membership for component {xname} Display group labels and partition names for a given component xname ID.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Component xname ID (i.e. locational identifier)

@return Membership100

func (*MembershipApiService) DoMembershipsGet ¶

func (a *MembershipApiService) DoMembershipsGet(ctx context.Context, localVarOptionals *MembershipApiDoMembershipsGetOpts) ([]Membership100, *http.Response, error)

type Message100ExtendedInfo ¶

type Message100ExtendedInfo struct {
	// Formal, machine readable, name for message.
	ID string `json:"ID,omitempty"`
	// Human readable description of message.
	Message string      `json:"Message,omitempty"`
	Flag    *HmsFlag100 `json:"Flag,omitempty"`
}

TODO This is a general message scheme meant to replace and generalize old HSS error codes. Largely TBD placeholder.

type NetType100 ¶

type NetType100 string

NetType100 : This is the type of high speed network the component is connected to, if it is an applicable component type and the interface is present, or the type of the system HSN.

const (
	SLING_NetType100      NetType100 = "Sling"
	INFINIBAND_NetType100 NetType100 = "Infiniband"
	ETHERNET_NetType100   NetType100 = "Ethernet"
	OEM_NetType100        NetType100 = "OEM"
	NONE_NetType100       NetType100 = "None"
)

List of NetType.1.0.0

type NodeMap100NodeMap ¶

type NodeMap100NodeMap struct {
	ID string `json:"ID,omitempty"`
	// Positive default Node ID (NID) for the xname in ID
	NID     int32  `json:"NID"`
	Role    string `json:"Role,omitempty"`
	SubRole string `json:"SubRole,omitempty"`
}

NodeMaps are a way of pre-populating state manager with a set of valid node xnames (currently populated, or just potentially populated) and assigning each a default NID (and optionally also a Role and SubRole). NID is required and must be unique within the NodeMaps. When components are first discovered, if a matching NodeMap entry is found, that NID will be used to create the component entry. This allows NIDs to be defined in advance in an orderly way that allows NID ranges to be consecutive on the set of xnames that is actually used for a particular hardware config. The default NIDs used if no NodeMap is present are based on enumerating NIDs for ALL POSSIBLE xnames, even though in practice only a small subset will be used for any particular hardware config (resulting in very sparse assignments). NodeMaps, then, help avoid this. Updating NodeMaps for already discovered components (unless they are deleted and then rediscovered) will not automatically update the NID field in States/Components. Likewise using a patch to update NID on a particular entry in States/Components will not automatically define or update a NodeMap entry.

type NodeMap100PostNodeMap ¶

type NodeMap100PostNodeMap struct {
	ID string `json:"ID"`
	// Positive default Node ID (NID) for the xname in ID
	NID     int32  `json:"NID"`
	Role    string `json:"Role,omitempty"`
	SubRole string `json:"SubRole,omitempty"`
}

NodeMaps are a way of pre-populating state manager with a set of valid node xnames (currently populated, or just potentially populated) and assigning each a default NID (and optionally also a Role and SubRole). NID is required and must be unique within the NodeMaps. When components are first discovered, if a matching NodeMap entry is found, that NID will be used to create the component entry. This allows NIDs to be defined in advance in an orderly way that allows NID ranges to be consecutive on the set of xnames that is actually used for a particular hardware config. The default NIDs used if no NodeMap is present are based on enumerating NIDs for ALL POSSIBLE xnames, even though in practice only a small subset will be used for any particular hardware config (resulting in very sparse assignments). NodeMaps, then, help avoid this. Updating NodeMaps for already discovered components (unless they are deleted and then rediscovered) will not automatically update the NID field in States/Components. Likewise using a patch to update NID on a particular entry in States/Components will not automatically define or update a NodeMap entry.

type NodeMapApiService ¶

type NodeMapApiService service

func (*NodeMapApiService) DoNodeMapDelete ¶

func (a *NodeMapApiService) DoNodeMapDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

NodeMapApiService Delete NodeMap with ID {xname} Delete NodeMap entry for a specific node {xname}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of NodeMap record to delete.

@return Response100

func (*NodeMapApiService) DoNodeMapGet ¶

func (a *NodeMapApiService) DoNodeMapGet(ctx context.Context, xname string) (NodeMap100NodeMap, *http.Response, error)

NodeMapApiService Retrieve NodeMap at {xname} Retrieve NodeMap, i.e. defaults NID/Role/etc. for node located at physical location {xname}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of NodeMap record to return.

@return NodeMap100NodeMap

func (*NodeMapApiService) DoNodeMapPost ¶

func (a *NodeMapApiService) DoNodeMapPost(ctx context.Context, body NodeMapArrayNodeMapArray) (Response100, *http.Response, error)

NodeMapApiService Create or Modify NodeMaps Create or update the given set of NodeMaps whose ID fields are each a valid xname. The NID field is required and serves as the NID that will be used when a component with the same xname ID is created for the first time by discovery. Role is an optional field. A node is assigned the default (e.g. Compute) role when it is first created during discovery. The NID must be unique across all entries. SubRole is an optional field. A node is assigned no subrole by default when it is first created during discovery. The NodeMaps collection should be uploaded at install time by specifying it as a JSON file. As a result, when the endpoints are automatically discovered by REDS, and inventory discovery is performed by HSM, the desired NID numbers will be set as soon as the nodes are created using the NodeMaps collection. All node xnames that are expected to be used in the system should be included in the mapping, even if not currently populated. It is recommended that NodeMaps are uploaded at install time before discovery happens. If they are uploaded after discovery, then the node xnames need to be manually updated with the correct NIDs. You can update NIDs for individual components by using PATCH /State/Components/{xname}/NID. Note the following points: * If the POST operation contains an xname that already exists, the entry will be overwritten with the new entry (i.e. new NID, Role (if given), etc.). * The same NID cannot be used for more than one xname. If such a duplicate would be created, the operation will fail. * If the node has already been discovered for the first time (that is, it exists in /hsm/v2/State/Components and already has a previous/default NID), modifying the NodeMap entry will not automatically reassign the current NID. * If you wish to use POST to completely replace the current NodeMaps collection (rather than modifying it), first delete it using the DELETE method on the collection. Otherwise the current entries and the new ones will be merged if they are disjoint sets of nodes.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return Response100

func (*NodeMapApiService) DoNodeMapPut ¶

func (a *NodeMapApiService) DoNodeMapPut(ctx context.Context, body NodeMap100NodeMap, xname string) (NodeMap100PostNodeMap, *http.Response, error)

NodeMapApiService Update definition for NodeMap ID {xname} Update or create an entry for an individual node xname using PUT. Note the following points: * If the PUT operation contains an xname that already exists, the entry will be overwritten with the new entry (i.e. new NID, Role (if given), etc.). * The same NID cannot be used for more than one xname. If such a duplicate would be created, the operation will fail. * If the node has already been discovered for the first time (that is, it exists in /hsm/v2/State/Components and already has a previous/default NID), modifying the NodeMap entry will not automatically reassign the current NID.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of NodeMap record to create or update.

@return NodeMap100PostNodeMap

func (*NodeMapApiService) DoNodeMapsDeleteAll ¶

func (a *NodeMapApiService) DoNodeMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

NodeMapApiService Delete all NodeMap entities Delete all entries in the NodeMaps collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*NodeMapApiService) DoNodeMapsGet ¶

func (a *NodeMapApiService) DoNodeMapsGet(ctx context.Context) (NodeMapArrayNodeMapArray, *http.Response, error)

NodeMapApiService Retrieve all NodeMaps, returning NodeMapArray Retrieve all Node map entries as a named array, or an empty array if the collection is empty.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return NodeMapArrayNodeMapArray

type NodeMapArrayNodeMapArray ¶

type NodeMapArrayNodeMapArray struct {
	// Contains the NodeMap objects in the array.
	NodeMaps []NodeMap100PostNodeMap `json:"NodeMaps,omitempty"`
}

This is a named array of NodeMap objects. This is the result of GET-ing the NodeMaps collection, or can be used to populate or update it as input provided via POST.

type Partition100 ¶

type Partition100 struct {
	Name string `json:"name"`
	// A one-line, user-provided description of the partition.
	Description string `json:"description,omitempty"`
	// A free-form array of strings to provide extra organization/filtering. Not to be confused with labels/groups.
	Tags    []string    `json:"tags,omitempty"`
	Members *Members100 `json:"members,omitempty"`
}

A partition is a formal, non-overlapping division of the system that forms an administratively distinct sub-system e.g. for implementing multi-tenancy.

type Partition100Patch ¶

type Partition100Patch struct {
	// A one-line, user-provided description of the group.
	Description string `json:"description,omitempty"`
	// A free-form array of strings to provide extra organization/filtering. Not to be confused with labels/groups.
	Tags []string `json:"tags,omitempty"`
}

To update the tags array and/or description, a PATCH operation can be used. If either field is omitted, it will not be updated. NOTE: This cannot be used to completely replace the members list Rather, individual members can be removed or added with the POST/DELETE /members API.

type PartitionApiDoPartitionsGetOpts ¶

type PartitionApiDoPartitionsGetOpts struct {
	Partition optional.String
	Tag       optional.String
}

type PartitionApiService ¶

type PartitionApiService service

func (*PartitionApiService) DoPartitionDelete ¶

func (a *PartitionApiService) DoPartitionDelete(ctx context.Context, partitionName string) (Response100, *http.Response, error)

PartitionApiService Delete existing partition with {partition_name} Delete partition {partition_name}. Any members previously in the partition will no longer have the deleted partition name associated with them.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param partitionName Partition name of the partition to delete.

@return Response100

func (*PartitionApiService) DoPartitionGet ¶

func (a *PartitionApiService) DoPartitionGet(ctx context.Context, partitionName string) (Partition100, *http.Response, error)

PartitionApiService Retrieve existing partition {partition_name} Retrieve the partition which was created with the given {partition_name}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param partitionName Partition name to be retrieved

@return Partition100

func (*PartitionApiService) DoPartitionMemberDelete ¶

func (a *PartitionApiService) DoPartitionMemberDelete(ctx context.Context, partitionName string, xnameId string) (Response100, *http.Response, error)

PartitionApiService Delete member from existing partition Delete component {xname_id} from the members of partition {partition_name}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param partitionName Existing partition {partition_name} to remove the member from.
@param xnameId Member of {partition_name} to remove.

@return Response100

func (*PartitionApiService) DoPartitionMembersGet ¶

func (a *PartitionApiService) DoPartitionMembersGet(ctx context.Context, partitionName string) (Members100, *http.Response, error)

PartitionApiService Retrieve all members of existing partition Retrieve all members of existing partition {partition_name}, optionally filtering the set, returning a members set that includes the component xname IDs.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param partitionName Existing partition {partition_name} to query the members of.

@return Members100

func (*PartitionApiService) DoPartitionMembersPost ¶

func (a *PartitionApiService) DoPartitionMembersPost(ctx context.Context, body MemberId, partitionName string) ([]ResourceUri100, *http.Response, error)

PartitionApiService Create new member of existing partition (via POST) Create a new member of partition {partition_name} with the component xname ID provided in the payload. New member should not already exist in the given partition

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param partitionName Existing partition {partition_name} to add the new member to.

@return []ResourceUri100

func (*PartitionApiService) DoPartitionNamesGet ¶

func (a *PartitionApiService) DoPartitionNamesGet(ctx context.Context) ([]string, *http.Response, error)

PartitionApiService Retrieve all existing partition names Retrieve a string array of all partition names that currently exist in HSM. These are just the names, not the complete partition records.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return []string

func (*PartitionApiService) DoPartitionPatch ¶

func (a *PartitionApiService) DoPartitionPatch(ctx context.Context, body Partition100Patch, partitionName string) (*http.Response, error)

PartitionApiService Update metadata for existing partition {partition_name} Update the tags array and/or description by using PATCH. Omitted fields are not updated. This cannot be used to completely replace the members list. Rather, individual members can be removed or added with the POST/DELETE {partition_name}/members API.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param partitionName Name of the partition to update.

func (*PartitionApiService) DoPartitionsGet ¶

func (a *PartitionApiService) DoPartitionsGet(ctx context.Context, localVarOptionals *PartitionApiDoPartitionsGetOpts) ([]Partition100, *http.Response, error)

func (*PartitionApiService) DoPartitionsPost ¶

func (a *PartitionApiService) DoPartitionsPost(ctx context.Context, body Partition100) ([]ResourceUri100, *http.Response, error)

PartitionApiService Create new partition (via POST) Create a new partition identified by the partition_name field. Partition names should be of the format p# or p#.# (hard_part.soft_part). Partition name should be given explicitly, and should not conflict with any existing partition, or an error will occur. In addition, the member list must not overlap with any existing partition.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return []ResourceUri100

type PowerControl100 ¶

type PowerControl100 struct {
	// Name of the power control interface.
	Name string `json:"Name,omitempty"`
	// The total amount of power available to the chassis for allocation. This may the power supply capacity, or power budget assigned to the chassis from an up-stream chassis.
	PowerCapacityWatts float64             `json:"PowerCapacityWatts,omitempty"`
	OEM                *PowerControl100Oem `json:"OEM,omitempty"`
	// The ID(s) of the resources associated with this Power Limit.
	RelatedItem []PowerControl100RelatedItem `json:"RelatedItem,omitempty"`
}

This is the power control info for the node. These fields are all passed through from a Redfish PowerControl object.

type PowerControl100Oem ¶

type PowerControl100Oem struct {
	Cray *PowerControl100OemCray `json:"Cray,omitempty"`
}

This is the manufacturer/provider specific extension moniker used to divide the Oem object into sections.

type PowerControl100OemCray ¶

type PowerControl100OemCray struct {
	// The total amount of power available to the chassis for allocation. This may the power supply capacity, or power budget assigned to the chassis from an up-stream chassis.
	PowerIdleWatts float64                           `json:"PowerIdleWatts,omitempty"`
	PowerLimit     *PowerControl100OemCrayPowerLimit `json:"PowerLimit,omitempty"`
	// Typical power consumption during ComputerSystem.ResetAction \"On\" operation.
	PowerResetWatts float64 `json:"PowerResetWatts,omitempty"`
}

This is the manufacturer/provider specific extension moniker used to divide the Oem object into sections.

type PowerControl100OemCrayPowerLimit ¶

type PowerControl100OemCrayPowerLimit struct {
	// The minimum allowed value for a PowerLimit's LimitInWatts. This is the estimated lowest value (most restrictive) power cap that can be achieved by the associated PowerControl resource.
	Min float64 `json:"Min,omitempty"`
	// The maximum allowed value for a PowerLimit's LimitInWatts. This is the estimated highest value (least restrictive) power cap that can be achieved by the associated PowerControl resource. Note that the actual maximum allowed LimitInWatts is the lesser of PowerLimit.Max or PowerControl.PowerAllocatedWatts.
	Max float64 `json:"Max,omitempty"`
}

Power limit status and configuration information for this chassis.

type PowerControl100RelatedItem ¶

type PowerControl100RelatedItem struct {
	// An ID of the resource associated with this Power Limit.
	OdataId string `json:"@odata.id,omitempty"`
}

type PowerMap100PostPowerMap ¶

type PowerMap100PostPowerMap struct {
	Id string `json:"id"`
	// A list of components that supply this component with power.
	PoweredBy []string `json:"poweredBy"`
}

PowerMaps used to show which components are powered by which power supplies.

type PowerMap100PowerMap ¶

type PowerMap100PowerMap struct {
	Id string `json:"id,omitempty"`
	// A list of components that supply this component with power.
	PoweredBy []string `json:"poweredBy"`
}

PowerMaps used to show which components are powered by which power supplies.

type PowerMapApiService ¶

type PowerMapApiService service

func (*PowerMapApiService) DoPowerMapDelete ¶

func (a *PowerMapApiService) DoPowerMapDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

PowerMapApiService Delete PowerMap with ID {xname} Delete PowerMap entry for a specific component {xname}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of PowerMap record to delete.

@return Response100

func (*PowerMapApiService) DoPowerMapGet ¶

func (a *PowerMapApiService) DoPowerMapGet(ctx context.Context, xname string) (PowerMap100PowerMap, *http.Response, error)

PowerMapApiService Retrieve PowerMap at {xname} Retrieve PowerMap for a component located at physical location {xname}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of PowerMap record to return.

@return PowerMap100PowerMap

func (*PowerMapApiService) DoPowerMapPut ¶

func (a *PowerMapApiService) DoPowerMapPut(ctx context.Context, body PowerMap100PowerMap, xname string) (Response100, *http.Response, error)

PowerMapApiService Update definition for PowerMap ID {xname} Update or create an entry for an individual component xname using PUT. If the PUT operation contains an xname that already exists, the entry will be overwritten with the new entry.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of PowerMap record to create or update.

@return Response100

func (*PowerMapApiService) DoPowerMapsDeleteAll ¶

func (a *PowerMapApiService) DoPowerMapsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

PowerMapApiService Delete all PowerMap entities Delete all entries in the PowerMaps collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*PowerMapApiService) DoPowerMapsGet ¶

func (a *PowerMapApiService) DoPowerMapsGet(ctx context.Context) ([]PowerMap100PostPowerMap, *http.Response, error)

PowerMapApiService Retrieve all PowerMaps, returning PowerMapArray Retrieve all power map entries as a named array, or an empty array if the collection is empty.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return []PowerMap100PostPowerMap

func (*PowerMapApiService) DoPowerMapsPost ¶

func (a *PowerMapApiService) DoPowerMapsPost(ctx context.Context, body []PowerMap100PostPowerMap) (Response100, *http.Response, error)

PowerMapApiService Create or Modify PowerMaps Create or update the given set of PowerMaps whose ID fields are each a valid xname. The poweredBy field is required.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return Response100

type Problem7807 ¶

type Problem7807 struct {
	Type_    string  `json:"type"`
	Detail   string  `json:"detail,omitempty"`
	Instance string  `json:"instance,omitempty"`
	Status   float64 `json:"status,omitempty"`
	Title    string  `json:"title,omitempty"`
}

RFC 7807 compliant error payload. All fields are optional except the 'type' field.

type RedfishEndpoint100RedfishEndpoint ¶

type RedfishEndpoint100RedfishEndpoint struct {
	ID    string      `json:"ID"`
	Type_ *HmsType100 `json:"Type,omitempty"`
	// This is an arbitrary, user-provided name for the endpoint.  It can describe anything that is not captured by the ID/xname.
	Name string `json:"Name,omitempty"`
	// Hostname of the endpoint's FQDN, will always be the host portion of the fully-qualified domain name. Note that the hostname should normally always be the same as the ID field (i.e. xname) of the endpoint.
	Hostname string `json:"Hostname,omitempty"`
	// Domain of the endpoint's FQDN.  Will always match remaining non-hostname portion of fully-qualified domain name (FQDN).
	Domain string `json:"Domain,omitempty"`
	// Fully-qualified domain name of RF endpoint on management network. This is not writable because it is made up of the Hostname and Domain.
	FQDN string `json:"FQDN,omitempty"`
	// To disable a component without deleting its data from the database, can be set to false
	Enabled bool   `json:"Enabled,omitempty"`
	UUID    string `json:"UUID,omitempty"`
	// Username to use when interrogating endpoint
	User string `json:"User,omitempty"`
	// Password to use when interrogating endpoint, normally suppressed in output.
	Password string `json:"Password,omitempty"`
	// Whether to use SSDP for discovery if the EP supports it.
	UseSSDP bool `json:"UseSSDP,omitempty"`
	// Whether the MAC must be used (e.g. in River) in setting up geolocation info so the endpoint's location in the system can be determined.  The MAC does not need to be provided when creating the endpoint if the endpoint type can arrive at a geolocated hostname on its own.
	MacRequired bool `json:"MacRequired,omitempty"`
	// This is the MAC on the of the Redfish Endpoint on the management network, i.e. corresponding to the FQDN field's Ethernet interface where the root service is running. Not the HSN MAC. This is a MAC address in the standard colon-separated 12 byte hex format.
	MACAddr string `json:"MACAddr,omitempty"`
	// This is the IP of the Redfish Endpoint on the management network, i.e. corresponding to the FQDN field's Ethernet interface where the root service is running. This may be IPv4 or IPv6
	IPAddress string `json:"IPAddress,omitempty"`
	// Trigger a rediscovery when endpoint info is updated.
	RediscoverOnUpdate bool `json:"RediscoverOnUpdate,omitempty"`
	// Links to a discovery template defining how the endpoint should be discovered.
	TemplateID    string                                          `json:"TemplateID,omitempty"`
	DiscoveryInfo *RedfishEndpoint100RedfishEndpointDiscoveryInfo `json:"DiscoveryInfo,omitempty"`
}

This describes a RedfishEndpoint that is interrogated in order to perform discovery of the components below it. It is a BMC or card/blade controller or other device that operates a Redfish entry point through which the components underneath it may be discovered and managed.

type RedfishEndpoint100RedfishEndpointDiscoveryInfo ¶

type RedfishEndpoint100RedfishEndpointDiscoveryInfo struct {
	// The time the last discovery attempt took place.
	LastDiscoveryAttempt time.Time `json:"LastDiscoveryAttempt,omitempty"`
	// Describes the outcome of the last discovery attempt.
	LastDiscoveryStatus string `json:"LastDiscoveryStatus,omitempty"`
	// Version of Redfish as reported by the RF service root.
	RedfishVersion string `json:"RedfishVersion,omitempty"`
}

Contains info about the discovery status of the given endpoint.

type RedfishEndpoint100ResourceUriCollection ¶

type RedfishEndpoint100ResourceUriCollection struct {
	// Should describe the collection, though the type of resources the links correspond to should also be inferred from the context in which the collection was obtained.
	Name string `json:"Name,omitempty"`
	// An array of ResourceIds.
	Members []ResourceUri100 `json:"Members,omitempty"`
	// Number of ResourceURIs in the collection
	MemberCount float64 `json:"MemberCount,omitempty"`
}

type RedfishEndpointApiDoRedfishEndpointsGetOpts ¶

type RedfishEndpointApiDoRedfishEndpointsGetOpts struct {
	Id                  optional.String
	Fqdn                optional.String
	Type_               optional.String
	Uuid                optional.String
	Macaddr             optional.String
	Ipaddress           optional.String
	Lastdiscoverystatus optional.String
}

type RedfishEndpointApiService ¶

type RedfishEndpointApiService service

func (*RedfishEndpointApiService) DoRedfishEndpointDelete ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointDelete(ctx context.Context, xname string) (Response100, *http.Response, error)

RedfishEndpointApiService Delete RedfishEndpoint with ID {xname} Delete RedfishEndpoint record for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of RedfishEndpoint record to delete.

@return Response100

func (*RedfishEndpointApiService) DoRedfishEndpointGet ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointGet(ctx context.Context, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)

RedfishEndpointApiService Retrieve RedfishEndpoint at {xname} Retrieve RedfishEndpoint, located at physical location {xname}.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of RedfishEndpoint record to return.

@return RedfishEndpoint100RedfishEndpoint

func (*RedfishEndpointApiService) DoRedfishEndpointPatch ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointPatch(ctx context.Context, body RedfishEndpoint100RedfishEndpoint, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)

RedfishEndpointApiService Update (PATCH) definition for RedfishEndpoint ID {xname} Update (PATCH) RedfishEndpoint record for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of RedfishEndpoint record to create or update.

@return RedfishEndpoint100RedfishEndpoint

func (*RedfishEndpointApiService) DoRedfishEndpointPut ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointPut(ctx context.Context, body RedfishEndpoint100RedfishEndpoint, xname string) (RedfishEndpoint100RedfishEndpoint, *http.Response, error)

RedfishEndpointApiService Update definition for RedfishEndpoint ID {xname} Create or update RedfishEndpoint record for a specific xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param xname Locational xname of RedfishEndpoint record to create or update.

@return RedfishEndpoint100RedfishEndpoint

func (*RedfishEndpointApiService) DoRedfishEndpointQueryGet ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointQueryGet(ctx context.Context, xname string) (RedfishEndpointArrayRedfishEndpointArray, *http.Response, error)

RedfishEndpointApiService Retrieve RedfishEndpoint query for {xname}, returning RedfishEndpointArray Given xname and modifiers in query string, retrieve zero or more RedfishEndpoint entries in the form of a RedfishEndpointArray.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param xname Locational xname of RedfishEndpoint to query.

@return RedfishEndpointArrayRedfishEndpointArray

func (*RedfishEndpointApiService) DoRedfishEndpointsDeleteAll ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

RedfishEndpointApiService Delete all RedfishEndpoints Delete all entries in the RedfishEndpoint collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*RedfishEndpointApiService) DoRedfishEndpointsGet ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointsGet(ctx context.Context, localVarOptionals *RedfishEndpointApiDoRedfishEndpointsGetOpts) (RedfishEndpointArrayRedfishEndpointArray, *http.Response, error)

func (*RedfishEndpointApiService) DoRedfishEndpointsPost ¶

func (a *RedfishEndpointApiService) DoRedfishEndpointsPost(ctx context.Context, body RedfishEndpoint100RedfishEndpoint) ([]ResourceUri100, *http.Response, error)

RedfishEndpointApiService Create RedfishEndpoint(s) Create a new RedfishEndpoint whose ID field is a valid xname. ID can be given explicitly, or if the Hostname or hostname portion of the FQDN is given, and is a valid xname, this will be used for the ID instead. The Hostname/Domain can be given as separate fields and will be used to create a FQDN if one is not given. The reverse is also true. If FQDN is an IP address it will be treated as a hostname with a blank domain. The domain field is used currently to assign the domain for discovered nodes automatically. If ID is given and is a valid XName, the hostname/domain/FQDN does not need to have an XName as the hostname portion. It can be any address. The ID and FQDN must be unique across all entries.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return []ResourceUri100

type RedfishEndpointArrayPostQuery ¶

type RedfishEndpointArrayPostQuery struct {
	// An array of XName/ID values for the RedfishEndpoints to query.
	RedfishEndpointIDs []string `json:"RedfishEndpointIDs"`
	Partition          string   `json:"partition,omitempty"`
}

There are limits to the length of an HTTP URL and query string. Hence, if we wish to query an arbitrary list of XName/IDs, it will need to be in the body of the request. This object is used for this purpose. It is similar to the analogous GET operation.

type RedfishEndpointArrayRedfishEndpointArray ¶

type RedfishEndpointArrayRedfishEndpointArray struct {
	// Contains the HMS RedfishEndpoint objects in the array.
	RedfishEndpoints []RedfishEndpoint100RedfishEndpoint `json:"RedfishEndpoints,omitempty"`
}

This is a collection of RedfishEndpoint objects returned whenever a query is expected to result in 0 to n matches.

type RedfishSubtype100 ¶

type RedfishSubtype100 string

RedfishSubtype100 : This is the type corresponding to the Redfish object type, i.e. the ChassisType field, SystemType, ManagerType fields. We only use these three types to create ComponentEndpoints for now.

const (
	RACK_RedfishSubtype100                   RedfishSubtype100 = "Rack"
	BLADE_RedfishSubtype100                  RedfishSubtype100 = "Blade"
	ENCLOSURE_RedfishSubtype100              RedfishSubtype100 = "Enclosure"
	STAND_ALONE_RedfishSubtype100            RedfishSubtype100 = "StandAlone"
	RACK_MOUNT_RedfishSubtype100             RedfishSubtype100 = "RackMount"
	CARD_RedfishSubtype100                   RedfishSubtype100 = "Card"
	CARTRIDGE_RedfishSubtype100              RedfishSubtype100 = "Cartridge"
	ROW_RedfishSubtype100                    RedfishSubtype100 = "Row"
	POD_RedfishSubtype100                    RedfishSubtype100 = "Pod"
	EXPANSION_RedfishSubtype100              RedfishSubtype100 = "Expansion"
	SIDECAR_RedfishSubtype100                RedfishSubtype100 = "Sidecar"
	ZONE_RedfishSubtype100                   RedfishSubtype100 = "Zone"
	SLED_RedfishSubtype100                   RedfishSubtype100 = "Sled"
	SHELF_RedfishSubtype100                  RedfishSubtype100 = "Shelf"
	DRAWER_RedfishSubtype100                 RedfishSubtype100 = "Drawer"
	MODULE_RedfishSubtype100                 RedfishSubtype100 = "Module"
	COMPONENT_RedfishSubtype100              RedfishSubtype100 = "Component"
	OTHER_RedfishSubtype100                  RedfishSubtype100 = "Other"
	PHYSICAL_RedfishSubtype100               RedfishSubtype100 = "Physical"
	VIRTUAL_RedfishSubtype100                RedfishSubtype100 = "Virtual"
	OS_RedfishSubtype100                     RedfishSubtype100 = "OS"
	PHYSICALLY_PARTITIONED_RedfishSubtype100 RedfishSubtype100 = "PhysicallyPartitioned"
	VIRTUALLY_PARTITIONED_RedfishSubtype100  RedfishSubtype100 = "VirtuallyPartitioned"
	MANAGEMENT_CONTROLLER_RedfishSubtype100  RedfishSubtype100 = "ManagementController"
	ENCLOSURE_MANAGER_RedfishSubtype100      RedfishSubtype100 = "EnclosureManager"
	BMC_RedfishSubtype100                    RedfishSubtype100 = "BMC"
	RACK_MANAGER_RedfishSubtype100           RedfishSubtype100 = "RackManager"
	AUXILIARY_CONTROLLER_RedfishSubtype100   RedfishSubtype100 = "AuxiliaryController"
)

List of RedfishSubtype.1.0.0

type RedfishType100 ¶

type RedfishType100 string

RedfishType100 : This is the Redfish object type, not to be confused with the HMS component type.

const (
	CHASSIS_RedfishType100            RedfishType100 = "Chassis"
	COMPUTER_SYSTEM_RedfishType100    RedfishType100 = "ComputerSystem"
	ETHERNET_INTERFACE_RedfishType100 RedfishType100 = "EthernetInterface"
	MANAGER_RedfishType100            RedfishType100 = "Manager"
	MEMORY_RedfishType100             RedfishType100 = "Memory"
	PROCESSOR_RedfishType100          RedfishType100 = "Processor"
	DRIVE_RedfishType100              RedfishType100 = "Drive"
	POWER_SUPPLY_RedfishType100       RedfishType100 = "PowerSupply"
	ACCOUNT_SERVICE_RedfishType100    RedfishType100 = "AccountService"
	EVENT_SERVICE_RedfishType100      RedfishType100 = "EventService"
	LOG_SERVICE_RedfishType100        RedfishType100 = "LogService"
	SESSION_SERVICE_RedfishType100    RedfishType100 = "SessionService"
	TASK_SERVICE_RedfishType100       RedfishType100 = "TaskService"
	UPDATE_SERVICE_RedfishType100     RedfishType100 = "UpdateService"
)

List of RedfishType.1.0.0

type ReservedKeys100 ¶

type ReservedKeys100 struct {
	ReservationKeys []XnameWithKey100 `json:"ReservationKeys,omitempty"`
	// Rigid is all or nothing, flexible is best attempt.
	ProcessingModel string `json:"ProcessingModel,omitempty"`
}

type ReservedKeysWithRenewal100 ¶

type ReservedKeysWithRenewal100 struct {
	ReservationKeys []XnameWithKey100 `json:"ReservationKeys,omitempty"`
	// Rigid is all or nothing, flexible is best attempt.
	ProcessingModel string `json:"ProcessingModel,omitempty"`
	// Length of time in minutes for the reservation to be valid for.
	ReservationDuration int32 `json:"ReservationDuration,omitempty"`
}

type ResourceUri100 ¶

type ResourceUri100 struct {
	ResourceURI string `json:"ResourceURI,omitempty"`
}

A ResourceURI is like an odata.id, it provides a path to a resource from the API root, such that when a GET is performed, the corresponding object is returned. It does not imply other odata functionality.

type ResourceUriCollectionResourceUriCollection ¶

type ResourceUriCollectionResourceUriCollection struct {
	// Should describe the collection, though the type of resources the links correspond to should also be inferred from the context in which the collection was obtained.
	Name string `json:"Name,omitempty"`
	// An array of ResourceIds.
	Members []ResourceUri100 `json:"Members,omitempty"`
	// Number of ResourceURIs in the collection
	MemberCount float64 `json:"MemberCount,omitempty"`
}

A ResourceURI is like an odata.id, it provides a path to a resource from the API root, such that when a GET is performed, the corresponding object is returned. It does not imply other odata functionality. This is a collection of such IDs, of a single base type, grouped together for some purpose.

type Response100 ¶

type Response100 struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

This is a simple CAPMC-like response, intended mainly for non-error messages. For client errors, we now use RFC7807 responses.

type SCNApiService ¶

type SCNApiService service

func (*SCNApiService) DoDeleteSCNSubscription ¶

func (a *SCNApiService) DoDeleteSCNSubscription(ctx context.Context, id string) (*http.Response, error)

SCNApiService Delete a state change notification subscription Delete a state change notification subscription.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id This is the ID associated with the subscription that was generated at its creation.

func (*SCNApiService) DoDeleteSCNSubscriptionsAll ¶

func (a *SCNApiService) DoDeleteSCNSubscriptionsAll(ctx context.Context) (*http.Response, error)

SCNApiService Delete all state change notification subscriptions Delete all subscriptions.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

func (*SCNApiService) DoGetSCNSubscription ¶

func (a *SCNApiService) DoGetSCNSubscription(ctx context.Context, id string) (SubscriptionsScnPostSubscription, *http.Response, error)

SCNApiService Retrieve a currently-held state change notification subscription Return the information on a currently held state change notification subscription

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id This is the ID associated with the subscription that was generated at its creation.

@return SubscriptionsScnPostSubscription

func (*SCNApiService) DoGetSCNSubscriptionsAll ¶

func (a *SCNApiService) DoGetSCNSubscriptionsAll(ctx context.Context) (SubscriptionsScnSubscriptionArray, *http.Response, error)

SCNApiService Retrieve currently-held state change notification subscriptions Retrieve all information on currently held state change notification subscriptions.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return SubscriptionsScnSubscriptionArray

func (*SCNApiService) DoPatchSCNSubscription ¶

func (a *SCNApiService) DoPatchSCNSubscription(ctx context.Context, body SubscriptionsScnPatchSubscription, id string) (*http.Response, error)

SCNApiService Update a subscription for state change notifications Update a subscription for state change notifications to add or remove triggers.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param id This is the ID associated with the subscription that was generated at its creation.

func (*SCNApiService) DoPostSCNSubscription ¶

func (a *SCNApiService) DoPostSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription) (SubscriptionsScnSubscriptionArrayItem100, *http.Response, error)

SCNApiService Create a subscription for state change notifications Request a subscription for state change notifications for a set of component states. This will create a new subscription and produce a unique ID for the subscription. This will not affect the existing subscriptions.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body

@return SubscriptionsScnSubscriptionArrayItem100

func (*SCNApiService) DoPutSCNSubscription ¶

func (a *SCNApiService) DoPutSCNSubscription(ctx context.Context, body SubscriptionsScnPostSubscription, id string) (*http.Response, error)

SCNApiService Update a subscription for state change notifications Update an existing state change notification subscription in whole. This will overwrite the specified subscription.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body
@param id This is the ID associated with the subscription that was generated at its creation.

type ServiceEndpoint100ServiceEndpoint ¶

type ServiceEndpoint100ServiceEndpoint struct {
	RedfishEndpointID string             `json:"RedfishEndpointID,omitempty"`
	RedfishType       *RedfishType100    `json:"RedfishType,omitempty"`
	RedfishSubtype    *RedfishSubtype100 `json:"RedfishSubtype,omitempty"`
	UUID              string             `json:"UUID,omitempty"`
	OdataID           string             `json:"OdataID,omitempty"`
	// This is a back-reference to the fully-qualified domain name of the parent Redfish endpoint that was used to discover the component.  It is the RedfishEndpointID field i.e. the hostname/xname plus its current domain.
	RedfishEndpointFQDN string `json:"RedfishEndpointFQDN,omitempty"`
	// This is the complete URL to the corresponding Redfish object, combining the RedfishEndpoint's FQDN and the OdataID.
	RedfishURL  string                         `json:"RedfishURL,omitempty"`
	ServiceInfo *ServiceEndpoint100ServiceInfo `json:"ServiceInfo,omitempty"`
}

This describes a service running on a Redfish endpoint and is populated when Redfish endpoint discovery occurs. It is used by clients who need to interact directly with the service via Redfish. There are also ComponentEndpoints, which represent Redfish components of a physical type (i.e., we track their state as components), which are also discovered when the Redfish Endpoint is discovered. The RedfishEndpointID is just the ID of the parent Redfish endpoint. As there are many service types per endpoint, the RedfishType must also be included to get a unique entry for a service. Services do not have their own xnames, and so they are identified by thee combination of the RedfishEndpointID they are running on, plus the RedfishType value (e.g. AccountService, TaskService, etc.). NOTE: These records are discovered, not created, and therefore are not writable (since any changes would be overwritten by a subsequent discovery).

type ServiceEndpoint100ServiceInfo ¶

type ServiceEndpoint100ServiceInfo struct {
	// The name of the service.
	Name string `json:"Name,omitempty"`
}

This is any additional information for the service. This is service specific. Schema for Redfish services can be found at https://redfish.dmtf.org/redfish/schema_index

type ServiceEndpointApiDoServiceEndpointsGetAllOpts ¶

type ServiceEndpointApiDoServiceEndpointsGetAllOpts struct {
	RedfishEp optional.String
	Service   optional.String
}

type ServiceEndpointApiDoServiceEndpointsGetOpts ¶

type ServiceEndpointApiDoServiceEndpointsGetOpts struct {
	RedfishEp optional.String
}

type ServiceEndpointApiService ¶

type ServiceEndpointApiService service

func (*ServiceEndpointApiService) DoServiceEndpointDelete ¶

func (a *ServiceEndpointApiService) DoServiceEndpointDelete(ctx context.Context, service string, xname string) (Response100, *http.Response, error)

ServiceEndpointApiService Delete the {service} ServiceEndpoint managed by {xname} Delete the {service} ServiceEndpoint managed by {xname}

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param service The Redfish service type of the ServiceEndpoint record to delete.
@param xname The locational xname of the RedfishEndpoint that manages the ServiceEndpoint record to delete.

@return Response100

func (*ServiceEndpointApiService) DoServiceEndpointGet ¶

func (a *ServiceEndpointApiService) DoServiceEndpointGet(ctx context.Context, service string, xname string) (ServiceEndpoint100ServiceEndpoint, *http.Response, error)

ServiceEndpointApiService Retrieve the ServiceEndpoint of a {service} managed by {xname} Retrieve the ServiceEndpoint for a Redfish service that is managed by xname.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param service The Redfish service type of the ServiceEndpoint record to return.
@param xname The locational xname of the RedfishEndpoint that manages the ServiceEndpoint record to return.

@return ServiceEndpoint100ServiceEndpoint

func (*ServiceEndpointApiService) DoServiceEndpointsDeleteAll ¶

func (a *ServiceEndpointApiService) DoServiceEndpointsDeleteAll(ctx context.Context) (Response100, *http.Response, error)

ServiceEndpointApiService Delete all ServiceEndpoints Delete all entries in the ServiceEndpoint collection.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*ServiceEndpointApiService) DoServiceEndpointsGet ¶

func (a *ServiceEndpointApiService) DoServiceEndpointsGet(ctx context.Context, service string, localVarOptionals *ServiceEndpointApiDoServiceEndpointsGetOpts) (ServiceEndpointArrayServiceEndpointArray, *http.Response, error)

func (*ServiceEndpointApiService) DoServiceEndpointsGetAll ¶

func (a *ServiceEndpointApiService) DoServiceEndpointsGetAll(ctx context.Context, localVarOptionals *ServiceEndpointApiDoServiceEndpointsGetAllOpts) (ServiceEndpointArrayServiceEndpointArray, *http.Response, error)

type ServiceEndpointArrayServiceEndpointArray ¶

type ServiceEndpointArrayServiceEndpointArray struct {
	// Contains the HMS ServiceEndpoint objects in the array.
	ServiceEndpoints []ServiceEndpoint100ServiceEndpoint `json:"ServiceEndpoints,omitempty"`
}

This is a collection of ServiceEndpoint objects returned whenever a query is expected to result in 0 to n matches.

type ServiceInfoApiService ¶

type ServiceInfoApiService service

func (*ServiceInfoApiService) DoArchValuesGet ¶

func (a *ServiceInfoApiService) DoArchValuesGet(ctx context.Context) (Values100ArchArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'arch' parameter Retrieve all valid values for use with the 'arch' (component architecture) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100ArchArray

func (*ServiceInfoApiService) DoClassValuesGet ¶

func (a *ServiceInfoApiService) DoClassValuesGet(ctx context.Context) (Values100ClassArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'class' parameter Retrieve all valid values for use with the 'class' (hardware class) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100ClassArray

func (*ServiceInfoApiService) DoFlagValuesGet ¶

func (a *ServiceInfoApiService) DoFlagValuesGet(ctx context.Context) (Values100FlagArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'flag' parameter Retrieve all valid values for use with the 'flag' (component flag) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100FlagArray

func (*ServiceInfoApiService) DoLivenessGet ¶

func (a *ServiceInfoApiService) DoLivenessGet(ctx context.Context) (*http.Response, error)

ServiceInfoApiService Kubernetes liveness endpoint to monitor service health The `liveness` resource works in conjunction with the Kubernetes liveness probe to determine when the service is no longer responding to requests. Too many failures of the liveness probe will result in the service being shut down and restarted. This is primarily an endpoint for the automated Kubernetes system.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

func (*ServiceInfoApiService) DoNetTypeValuesGet ¶

func (a *ServiceInfoApiService) DoNetTypeValuesGet(ctx context.Context) (Values100NetTypeArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'nettype' parameter Retrieve all valid values for use with the 'nettype' (component network type) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100NetTypeArray

func (*ServiceInfoApiService) DoReadyGet ¶

func (a *ServiceInfoApiService) DoReadyGet(ctx context.Context) (Response100, *http.Response, error)

ServiceInfoApiService Kubernetes readiness endpoint to monitor service health The `readiness` resource works in conjunction with the Kubernetes readiness probe to determine when the service is no longer healthy and able to respond correctly to requests. Too many failures of the readiness probe will result in the traffic being routed away from this service and eventually the service will be shut down and restarted if in an unready state for too long. This is primarily an endpoint for the automated Kubernetes system.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Response100

func (*ServiceInfoApiService) DoRoleValuesGet ¶

func (a *ServiceInfoApiService) DoRoleValuesGet(ctx context.Context) (Values100RoleArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'role' parameter Retrieve all valid values for use with the 'role' (component role) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100RoleArray

func (*ServiceInfoApiService) DoStateValuesGet ¶

func (a *ServiceInfoApiService) DoStateValuesGet(ctx context.Context) (Values100StateArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'state' parameter Retrieve all valid values for use with the 'state' (component state) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100StateArray

func (*ServiceInfoApiService) DoSubRoleValuesGet ¶

func (a *ServiceInfoApiService) DoSubRoleValuesGet(ctx context.Context) (Values100SubRoleArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'subrole' parameter Retrieve all valid values for use with the 'subrole' (component subrole) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100SubRoleArray

func (*ServiceInfoApiService) DoTypeValuesGet ¶

func (a *ServiceInfoApiService) DoTypeValuesGet(ctx context.Context) (Values100TypeArray, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use with the 'type' parameter Retrieve all valid values for use with the 'type' (component HMSType) parameter.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100TypeArray

func (*ServiceInfoApiService) DoValuesGet ¶

func (a *ServiceInfoApiService) DoValuesGet(ctx context.Context) (Values100Values, *http.Response, error)

ServiceInfoApiService Retrieve all valid values for use as parameters Retrieve all valid values for use as parameters.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return Values100Values

type ServiceReservationCheckResponse100 ¶

type ServiceReservationCheckResponse100 struct {
	Success []XnameKeysDeputyExpire100 `json:"Success,omitempty"`
	Failure []FailedXnames100          `json:"Failure,omitempty"`
}

type ServiceReservationCreate100 ¶

type ServiceReservationCreate100 struct {
	// An array of XName/ID values for the components to query.
	ComponentIDs []string `json:"ComponentIDs,omitempty"`
	// Partition name to filter on, as per current /partitions/names
	Partition []string `json:"Partition,omitempty"`
	// Group label to filter on, as per current /groups/labels
	Group []string `json:"Group,omitempty"`
	// Retrieve all components with the given HMS type.
	Type_ []string `json:"Type,omitempty"`
	// Retrieve all components with the given HMS state.
	State []HmsState100 `json:"State,omitempty"`
	// Retrieve all components with the given HMS flag value.
	Flag []HmsFlag100 `json:"Flag,omitempty"`
	// Retrieve all components with the given enabled status (true or false).
	Enabled []string `json:"Enabled,omitempty"`
	// Retrieve all components with the given software status. Software status is a free form string. Matching is case-insensitive.
	Softwarestatus []string `json:"Softwarestatus,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS role
	Role []string `json:"Role,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS subrole
	Subrole []string `json:"Subrole,omitempty"`
	// Retrieve all components with the given HMS subtype.
	Subtype []string `json:"Subtype,omitempty"`
	// Retrieve all components with the given architecture.
	Arch []HmsArch100 `json:"Arch,omitempty"`
	// Retrieve all components (i.e. nodes) with the given HMS hardware class. Class can be River, Mountain, etc.
	Class []HmsClass100 `json:"Class,omitempty"`
	// Retrieve all components (i.e. one node) with the given integer NID
	NID []string `json:"NID,omitempty"`
	// Rigid is all or nothing, flexible is best attempt.
	ProcessingModel string `json:"ProcessingModel,omitempty"`
	// Length of time in minutes for the reservation to be valid for.
	ReservationDuration int32 `json:"ReservationDuration,omitempty"`
}

type ServiceReservationCreateResponse100 ¶

type ServiceReservationCreateResponse100 struct {
	Success []XnameKeys100    `json:"Success,omitempty"`
	Failure []FailedXnames100 `json:"Failure,omitempty"`
}

type ServiceReservationsApiService ¶

type ServiceReservationsApiService service

func (*ServiceReservationsApiService) LocksServiceReservationsCheckPost ¶

func (a *ServiceReservationsApiService) LocksServiceReservationsCheckPost(ctx context.Context, body DeputyKeys100) (ServiceReservationCheckResponse100, *http.Response, error)

ServiceReservationsApiService Check the validity of reservations. Using xname + reservation key check on the validity of reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components & deputy keys to check on validity of reservations.

@return ServiceReservationCheckResponse100

func (*ServiceReservationsApiService) LocksServiceReservationsPost ¶

func (a *ServiceReservationsApiService) LocksServiceReservationsPost(ctx context.Context, body ServiceReservationCreate100) (ServiceReservationCreateResponse100, *http.Response, error)

ServiceReservationsApiService Create reservations Creates reservations on a set of xnames of finite duration. Component must be unlocked to create a reservation.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of components to create reservations. A `rigid` processing model will result in the entire set of xnames not having reservations created if an xname doesn't exist, or isn't locked, or if already reserved. A `flexible` processing model will perform all actions possible.

@return ServiceReservationCreateResponse100

func (*ServiceReservationsApiService) LocksServiceReservationsReleasePost ¶

func (a *ServiceReservationsApiService) LocksServiceReservationsReleasePost(ctx context.Context, body ReservedKeys100) (XnameResponse100, *http.Response, error)

ServiceReservationsApiService Releases existing reservations. Given a list of {xname & reservation key}, releases the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to release reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation released if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

func (*ServiceReservationsApiService) LocksServiceReservationsRenewPost ¶

func (a *ServiceReservationsApiService) LocksServiceReservationsRenewPost(ctx context.Context, body ReservedKeysWithRenewal100) (XnameResponse100, *http.Response, error)

ServiceReservationsApiService Renew existing reservations. Given a list of {xname & reservation key}, renews the associated reservations.

@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param body List of {xname and reservation key} to renew reservations. A `rigid` processing model will result in the entire set of xnames not having their reservation renewed if an xname doesn't exist, or isn't reserved. A `flexible` processing model will perform all actions possible.

@return XnameResponse100

type SubscriptionsScnPatchSubscription ¶

type SubscriptionsScnPatchSubscription struct {
	// The type of operation to be performed on the subscription
	Op string `json:"Op,omitempty"`
	// This value toggles subscriptions to state change notifications concerning components being disabled or enabled. 'true' will cause the subscriber to be notified about components being enabled or disabled. 'false' or empty will result in no such notifications.
	Enabled bool `json:"Enabled,omitempty"`
	// This is an array containing component roles for which to be notified when role changes occur.
	Roles []string `json:"Roles,omitempty"`
	// This is an array containing component subroles for which to be notified when subrole changes occur.
	SubRoles []string `json:"SubRoles,omitempty"`
	// This is an array containing component software statuses for which to be notified when software status changes occur.
	SoftwareStatus []string `json:"SoftwareStatus,omitempty"`
	// This is an array containing component states for which to be notified when state changes occur.
	States []HmsState100 `json:"States,omitempty"`
}

This is the JSON payload that contains state change notification subscription information.

type SubscriptionsScnPostSubscription ¶

type SubscriptionsScnPostSubscription struct {
	// This is the name of the subscriber.
	Subscriber string `json:"Subscriber,omitempty"`
	// This value toggles subscriptions to state change notifications concerning components being disabled or enabled. 'true' will cause the subscriber to be notified about components being enabled or disabled. 'false' or empty will result in no such notifications.
	Enabled bool `json:"Enabled,omitempty"`
	// This is an array containing component roles for which to be notified when role changes occur.
	Roles []string `json:"Roles,omitempty"`
	// This is an array containing component subroles for which to be notified when subrole changes occur.
	SubRoles []string `json:"SubRoles,omitempty"`
	// This is an array containing component software statuses for which to be notified when software status changes occur.
	SoftwareStatus []string `json:"SoftwareStatus,omitempty"`
	// This is an array containing component states for which to be notified when state changes occur.
	States []HmsState100 `json:"States,omitempty"`
	Url    string        `json:"Url,omitempty"`
}

This is the JSON payload that contains information to create a new state change notification subscription

type SubscriptionsScnSubscriptionArray ¶

type SubscriptionsScnSubscriptionArray struct {
	SubscriptionList []SubscriptionsScnSubscriptionArrayItem100 `json:"SubscriptionList,omitempty"`
}

List of all currently held state change notification subscriptions.

type SubscriptionsScnSubscriptionArrayItem100 ¶

type SubscriptionsScnSubscriptionArrayItem100 struct {
	ID         string `json:"ID,omitempty"`
	Subscriber string `json:"Subscriber,omitempty"`
	// This value toggles subscriptions to state change notifications concerning components being disabled or enabled. 'true' will cause the subscriber to be notified about components being enabled or disabled. 'false' or empty will result in no such notifications.
	Enabled bool `json:"Enabled,omitempty"`
	// This is an array containing component roles for which to be notified when role changes occur.
	Roles []string `json:"Roles,omitempty"`
	// This is an array containing component subroles for which to be notified when subrole changes occur.
	SubRoles []string `json:"SubRoles,omitempty"`
	// This is an array containing component software statuses for which to be notified when software status changes occur.
	SoftwareStatus []string `json:"SoftwareStatus,omitempty"`
	// This is an array containing component states for which to be notified when state changes occur.
	States []HmsState100 `json:"States,omitempty"`
	Url    string        `json:"Url,omitempty"`
}

State change notification subscription JSON payload.

type Values100ArchArray ¶

type Values100ArchArray struct {
	Arch []HmsArch100 `json:"Arch,omitempty"`
}

This is an array of valid HMSArch values. These values are valid for any 'arch' parameter in this API.

type Values100ClassArray ¶

type Values100ClassArray struct {
	Class []HmsClass100 `json:"Class,omitempty"`
}

This is an array of valid HMSClass values. These values are valid for any 'class' parameter in this API.

type Values100FlagArray ¶

type Values100FlagArray struct {
	Flag []HmsFlag100 `json:"Flag,omitempty"`
}

This is an array of valid HMSFlag values. These values are valid for any 'flag' parameter in this API.

type Values100NetTypeArray ¶

type Values100NetTypeArray struct {
	NetType []NetType100 `json:"NetType,omitempty"`
}

This is an array of valid NetType values. These values are valid for any 'nettype' parameter in this API.

type Values100RoleArray ¶

type Values100RoleArray struct {
	Role []string `json:"Role,omitempty"`
}

This is an array of valid HMSRole values. These values are valid for any 'role' parameter in this API.

type Values100StateArray ¶

type Values100StateArray struct {
	State []HmsState100 `json:"State,omitempty"`
}

This is an array of valid HMSState values. These values are valid for any 'state' parameter in this API.

type Values100SubRoleArray ¶

type Values100SubRoleArray struct {
	SubRole []string `json:"SubRole,omitempty"`
}

This is an array of valid HMSSubRole values. These values are valid for any 'subrole' parameter in this API.

type Values100TypeArray ¶

type Values100TypeArray struct {
	Type_ []HmsType100 `json:"Type,omitempty"`
}

This is an array of valid HMSType values. These values are valid for any 'type' parameter in this API.

type Values100Values ¶

type Values100Values struct {
	Class   []HmsClass100 `json:"Class,omitempty"`
	Flag    []HmsFlag100  `json:"Flag,omitempty"`
	NetType []NetType100  `json:"NetType,omitempty"`
	Role    []string      `json:"Role,omitempty"`
	SubRole []string      `json:"SubRole,omitempty"`
	State   []HmsState100 `json:"State,omitempty"`
	Type_   []HmsType100  `json:"Type,omitempty"`
	Arch    []HmsArch100  `json:"Arch,omitempty"`
}

This is a list of parameters and their valid values. These values are valid for various parameters in this API.

type XnameKeys100 ¶

type XnameKeys100 struct {
	ID string `json:"ID,omitempty"`
	// The key that can be passed to a delegate.
	DeputyKey string `json:"DeputyKey,omitempty"`
	// The key that can be used to renew/release the reservation. Should not be delegated or shared.
	ReservationKey string    `json:"ReservationKey,omitempty"`
	ExpirationTime time.Time `json:"ExpirationTime,omitempty"`
}

type XnameKeysDeputyExpire100 ¶

type XnameKeysDeputyExpire100 struct {
	ID string `json:"ID,omitempty"`
	// The key that can be passed to a delegate.
	DeputyKey      string    `json:"DeputyKey,omitempty"`
	ExpirationTime time.Time `json:"ExpirationTime,omitempty"`
}

type XnameKeysNoExpire100 ¶

type XnameKeysNoExpire100 struct {
	ID string `json:"ID,omitempty"`
	// The key that can be passed to a delegate.
	DeputyKey string `json:"DeputyKey,omitempty"`
	// The key that can be used to renew/release the reservation. Should not be delegated or shared.
	ReservationKey string `json:"ReservationKey,omitempty"`
}

type XnameResponse100 ¶

type XnameResponse100 struct {
	Counts  *Counts100        `json:"Counts,omitempty"`
	Success *Xnames           `json:"Success,omitempty"`
	Failure []FailedXnames100 `json:"Failure,omitempty"`
}

This is a simple CAPMC-like response, intended mainly for non-error messages. For client errors, we now use RFC7807 responses.

type XnameWithKey100 ¶

type XnameWithKey100 struct {
	ID  string `json:"ID,omitempty"`
	Key string `json:"Key,omitempty"`
}

type Xnames ¶

type Xnames struct {
	ComponentIDs []string `json:"ComponentIDs,omitempty"`
}

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL