973 lines
30 KiB
Python
Executable File
973 lines
30 KiB
Python
Executable File
#
|
|
# Copyright (c) 2015-2021 Wind River Systems, Inc.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
import copy
|
|
import json
|
|
from nfv_common import debug
|
|
|
|
from nfv_plugins.nfvi_plugins.openstack.objects import PLATFORM_SERVICE
|
|
from nfv_plugins.nfvi_plugins.openstack.rest_api import rest_api_request
|
|
|
|
DLOG = debug.debug_get_logger('nfv_plugins.nfvi_plugins.openstack.sysinv')
|
|
|
|
# WARNING: Any change to this timeout must be reflected in the config.ini
|
|
# file for the nfvi plugins.
|
|
REST_API_REQUEST_TIMEOUT = 45
|
|
|
|
|
|
KUBE_ROOTCA_UPDATE_ENDPOINT = "/kube_rootca_update"
|
|
KUBE_ROOTCA_UPDATE_GENERATE_CERT_ENDPOINT = \
|
|
KUBE_ROOTCA_UPDATE_ENDPOINT + "/generate_cert"
|
|
KUBE_ROOTCA_UPDATE_PODS_ENDPOINT = KUBE_ROOTCA_UPDATE_ENDPOINT + "/pods"
|
|
KUBE_ROOTCA_UPDATE_HOSTS_ENDPOINT = KUBE_ROOTCA_UPDATE_ENDPOINT + "/hosts"
|
|
KUBE_ROOTCA_UPDATE_UPLOAD_CERT_ENDPOINT = \
|
|
KUBE_ROOTCA_UPDATE_ENDPOINT + "/upload_cert"
|
|
|
|
|
|
# todo(abailey): refactor _api_get, etc.. into rest_api.py
|
|
def _api_cmd(token, endpoint):
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
api_cmd = url + endpoint
|
|
return api_cmd
|
|
|
|
|
|
def _api_cmd_headers():
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
return api_cmd_headers
|
|
|
|
|
|
def _api_delete(token, endpoint):
|
|
"""
|
|
Generic DELETE for a sysinv endpoint
|
|
"""
|
|
api_cmd = _api_cmd(token, endpoint)
|
|
api_cmd_headers = _api_cmd_headers()
|
|
response = rest_api_request(token,
|
|
"DELETE",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def _api_get(token, endpoint):
|
|
"""
|
|
Perform a generic GET for a particular sysinv API endpoint
|
|
"""
|
|
api_cmd = _api_cmd(token, endpoint)
|
|
response = rest_api_request(token,
|
|
"GET",
|
|
api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def _api_patch_dict(token, endpoint, patch_dict):
|
|
"""
|
|
Generic PATCH for a sysinv endpoint that passes a json dict
|
|
Some endpoints expect a dict, while others expect a list
|
|
"""
|
|
api_cmd = _api_cmd(token, endpoint)
|
|
api_cmd_headers = _api_cmd_headers()
|
|
return rest_api_request(token,
|
|
"PATCH",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
json.dumps(patch_dict),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
|
|
|
|
def _api_post(token, endpoint, api_cmd_payload):
|
|
"""
|
|
Generic POST to a sysinv endpoint with a payload
|
|
"""
|
|
api_cmd = _api_cmd(token, endpoint)
|
|
api_cmd_headers = _api_cmd_headers()
|
|
response = rest_api_request(token,
|
|
"POST",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_datanetworks(token, host_uuid):
|
|
"""
|
|
Get all data networks on a host.
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/" + host_uuid + "/interface_datanetworks"
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd, api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
result_data = response.result_data['interface_datanetworks']
|
|
|
|
return result_data
|
|
|
|
|
|
def get_system_info(token):
|
|
"""
|
|
Asks System Inventory for information about the system, such as
|
|
the name of the system
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/isystems"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_hosts(token):
|
|
"""
|
|
Asks System Inventory for a list of hosts
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_host(token, host_uuid):
|
|
"""
|
|
Asks System Inventory for a host details
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_host_labels(token, host_uuid):
|
|
"""
|
|
Asks System Inventory for host label details
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/labels" % host_uuid
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_kube_host_upgrades(token):
|
|
"""
|
|
Asks System Inventory for information about the kube host upgrades
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_host_upgrades"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_kube_rootca_update(token):
|
|
"""
|
|
Asks System Inventory for information about the kube rootca update
|
|
"""
|
|
return _api_get(token, KUBE_ROOTCA_UPDATE_ENDPOINT)
|
|
|
|
|
|
def get_kube_rootca_host_update_list(token):
|
|
"""
|
|
Asks System Inventory for information about the kube rootca host updates
|
|
"""
|
|
return _api_get(token, KUBE_ROOTCA_UPDATE_HOSTS_ENDPOINT)
|
|
|
|
|
|
def get_kube_upgrade(token):
|
|
"""
|
|
Asks System Inventory for information about the kube upgrade
|
|
"""
|
|
# todo(abailey): refactor using _api_get
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_upgrade"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_kube_version(token, kube_version):
|
|
"""
|
|
Asks System Inventory for information a kube version
|
|
"""
|
|
# todo(abailey): refactor using _api_get
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_versions/" + kube_version
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_kube_versions(token):
|
|
"""
|
|
Asks System Inventory for information about the kube versions
|
|
"""
|
|
# todo(abailey): refactor using _api_get
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_versions"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def kube_rootca_update_start(token, force=False, alarm_ignore_list=None):
|
|
"""
|
|
Ask System Inventory to start a kube rootca update
|
|
"""
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['force'] = force
|
|
if alarm_ignore_list is not None:
|
|
api_cmd_payload['alarm_ignore_list'] = copy.copy(alarm_ignore_list)
|
|
return _api_post(token, KUBE_ROOTCA_UPDATE_ENDPOINT, api_cmd_payload)
|
|
|
|
|
|
def kube_rootca_update_generate_cert(token, expiry_date=None, subject=None):
|
|
"""
|
|
Ask System Inventory to kube rootca update generate a cert
|
|
"""
|
|
api_cmd_payload = dict()
|
|
# even if these values are None, they need to be passed to sysinv API
|
|
api_cmd_payload['expiry_date'] = expiry_date
|
|
api_cmd_payload['subject'] = subject
|
|
return _api_post(token, KUBE_ROOTCA_UPDATE_GENERATE_CERT_ENDPOINT,
|
|
api_cmd_payload)
|
|
|
|
|
|
def kube_rootca_update_upload_cert(token, cert_file):
|
|
"""
|
|
Ask System Inventory to kube rootca update upload a cert file
|
|
This uses POST for a file, which urllib does not work well with.
|
|
"""
|
|
api_cmd = _api_cmd(token, KUBE_ROOTCA_UPDATE_UPLOAD_CERT_ENDPOINT)
|
|
api_cmd_headers = _api_cmd_headers()
|
|
api_cmd_payload = dict()
|
|
|
|
# The API is expecting requests.post formatted data
|
|
with open(cert_file, "rb") as cert_file_handle:
|
|
# file handle automatically closed once this request is sent
|
|
response = rest_api_request(token,
|
|
"POST",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT,
|
|
file_to_post=cert_file_handle)
|
|
return response
|
|
|
|
|
|
def kube_rootca_update_complete(token):
|
|
"""
|
|
Ask System Inventory to kube rootca update complete
|
|
"""
|
|
api_cmd_payload = list()
|
|
state_data = dict()
|
|
state_data['path'] = "/state"
|
|
state_data['value'] = 'update-completed'
|
|
state_data['op'] = "replace"
|
|
api_cmd_payload.append(state_data)
|
|
return _api_patch_dict(token,
|
|
KUBE_ROOTCA_UPDATE_ENDPOINT + "?force=True",
|
|
api_cmd_payload)
|
|
|
|
|
|
def kube_rootca_update_host(token, host_uuid, phase):
|
|
"""
|
|
Utility method to post to kube rootca update pods endpoint phase
|
|
Valid phase values are: [trust-both-cas, trust-new-ca, update-certs]
|
|
"""
|
|
api_cmd = "/ihosts/%s/kube_update_ca " % host_uuid
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['phase'] = phase
|
|
return _api_post(token, api_cmd, api_cmd_payload)
|
|
|
|
|
|
def kube_rootca_update_pods(token, phase):
|
|
"""
|
|
Utility method to post to kube rootca update pods endpoint phase
|
|
Valid phase values are: [trust-both-cas, trust-new-ca]
|
|
"""
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['phase'] = phase
|
|
return _api_post(token, KUBE_ROOTCA_UPDATE_PODS_ENDPOINT, api_cmd_payload)
|
|
|
|
|
|
def kube_upgrade_start(token, to_version, force=False, alarm_ignore_list=None):
|
|
"""
|
|
Ask System Inventory to start a kube upgrade
|
|
"""
|
|
# todo(abailey): refactor using _post_api_request
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_upgrade"
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['to_version'] = to_version
|
|
api_cmd_payload['force'] = force
|
|
if alarm_ignore_list is not None:
|
|
api_cmd_payload['alarm_ignore_list'] = copy.copy(alarm_ignore_list)
|
|
|
|
response = rest_api_request(token,
|
|
"POST",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def _patch_kube_upgrade_state(token, new_value):
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_upgrade"
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = list()
|
|
host_data = dict()
|
|
host_data['path'] = "/state"
|
|
host_data['value'] = new_value
|
|
host_data['op'] = "replace"
|
|
api_cmd_payload.append(host_data)
|
|
|
|
return rest_api_request(token,
|
|
"PATCH",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
|
|
|
|
def kube_upgrade_cleanup(token):
|
|
"""
|
|
Ask System Inventory to delete the kube upgrade
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/kube_upgrade"
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
response = rest_api_request(token, "DELETE", api_cmd, api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def kube_upgrade_complete(token):
|
|
"""
|
|
Ask System Inventory to kube upgrade complete
|
|
"""
|
|
return _patch_kube_upgrade_state(token, "upgrade-complete")
|
|
|
|
|
|
def kube_upgrade_download_images(token):
|
|
"""
|
|
Ask System Inventory to kube upgrade download images
|
|
"""
|
|
return _patch_kube_upgrade_state(token, "downloading-images")
|
|
|
|
|
|
def kube_upgrade_networking(token):
|
|
"""
|
|
Ask System Inventory to kube upgrade networking
|
|
"""
|
|
return _patch_kube_upgrade_state(token, "upgrading-networking")
|
|
|
|
|
|
def _kube_host_upgrade(token, host_uuid, target_operation, force):
|
|
"""
|
|
Invoke a POST for a host kube-upgrade operation
|
|
|
|
target_operation one of: kube_upgrade_control_plane, kube_upgrade_kubelet
|
|
force is a 'string'
|
|
"""
|
|
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/%s" % (host_uuid, target_operation)
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['force'] = force
|
|
|
|
response = rest_api_request(token,
|
|
"POST",
|
|
api_cmd,
|
|
api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def kube_host_upgrade_control_plane(token, host_uuid, force="true"):
|
|
"""
|
|
Ask System Inventory to kube HOST upgrade control plane
|
|
"""
|
|
return _kube_host_upgrade(token,
|
|
host_uuid,
|
|
"kube_upgrade_control_plane",
|
|
force)
|
|
|
|
|
|
def kube_host_upgrade_kubelet(token, host_uuid, force="true"):
|
|
"""
|
|
Ask System Inventory to kube HOST upgrade kubelet
|
|
"""
|
|
return _kube_host_upgrade(token,
|
|
host_uuid,
|
|
"kube_upgrade_kubelet",
|
|
force)
|
|
|
|
|
|
def get_upgrade(token):
|
|
"""
|
|
Asks System Inventory for information about the upgrade
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/upgrade"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def upgrade_start(token):
|
|
"""
|
|
Ask System Inventory to start an upgrade
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/upgrade"
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['force'] = "false"
|
|
|
|
response = rest_api_request(token, "POST", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def upgrade_activate(token):
|
|
"""
|
|
Ask System Inventory to activate an upgrade
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/upgrade"
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
host_data = dict()
|
|
host_data['path'] = "/state"
|
|
host_data['value'] = "activation-requested"
|
|
host_data['op'] = "replace"
|
|
|
|
api_cmd_payload = list()
|
|
api_cmd_payload.append(host_data)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def upgrade_complete(token):
|
|
"""
|
|
Ask System Inventory to complete an upgrade
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/upgrade"
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
response = rest_api_request(token, "DELETE", api_cmd, api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_host_lvgs(token, host_uuid):
|
|
"""
|
|
Asks System Inventory for a list logical volume groups for a host
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/ilvgs" % host_uuid
|
|
|
|
response = rest_api_request(token, "GET", api_cmd,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def notify_host_services_enabled(token, host_uuid):
|
|
"""
|
|
Notify System Inventory that host services are enabled
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['path'] = '/action'
|
|
api_cmd_payload['value'] = 'services-enabled'
|
|
api_cmd_payload['op'] = 'replace'
|
|
|
|
api_cmd_list = list()
|
|
api_cmd_list.append(api_cmd_payload)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_list),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def notify_host_services_disabled(token, host_uuid):
|
|
"""
|
|
Notify System Inventory that host services are disabled
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['path'] = '/action'
|
|
api_cmd_payload['value'] = 'services-disabled'
|
|
api_cmd_payload['op'] = 'replace'
|
|
|
|
api_cmd_list = list()
|
|
api_cmd_list.append(api_cmd_payload)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_list),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def notify_host_services_disable_extend(token, host_uuid):
|
|
"""
|
|
Notify System Inventory that host services disable needs to be extended
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload_action = dict()
|
|
api_cmd_payload_action['path'] = '/action'
|
|
api_cmd_payload_action['value'] = 'services-disable-extend'
|
|
api_cmd_payload_action['op'] = 'replace'
|
|
|
|
api_cmd_list = list()
|
|
api_cmd_list.append(api_cmd_payload_action)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_list),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def notify_host_services_disable_failed(token, host_uuid, reason):
|
|
"""
|
|
Notify System Inventory that host services disable failed
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload_action = dict()
|
|
api_cmd_payload_action['path'] = '/action'
|
|
api_cmd_payload_action['value'] = 'services-disable-failed'
|
|
api_cmd_payload_action['op'] = 'replace'
|
|
|
|
api_cmd_payload_reason = dict()
|
|
api_cmd_payload_reason['path'] = '/vim_progress_status'
|
|
api_cmd_payload_reason['value'] = str(reason)
|
|
api_cmd_payload_reason['op'] = 'replace'
|
|
|
|
api_cmd_list = list()
|
|
api_cmd_list.append(api_cmd_payload_action)
|
|
api_cmd_list.append(api_cmd_payload_reason)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_list),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def notify_host_services_deleted(token, host_uuid):
|
|
"""
|
|
Notify System Inventory that host services have been deleted
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
response = rest_api_request(token, "DELETE", api_cmd, api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def notify_host_services_delete_failed(token, host_uuid, reason):
|
|
"""
|
|
Notify System Inventory that host services delete failed
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload_action = dict()
|
|
api_cmd_payload_action['path'] = '/action'
|
|
api_cmd_payload_action['value'] = 'services-delete-failed'
|
|
api_cmd_payload_action['op'] = 'replace'
|
|
|
|
api_cmd_payload_reason = dict()
|
|
api_cmd_payload_reason['path'] = '/vim_progress_status'
|
|
api_cmd_payload_reason['value'] = str(reason)
|
|
api_cmd_payload_reason['op'] = 'replace'
|
|
|
|
api_cmd_list = list()
|
|
api_cmd_list.append(api_cmd_payload_action)
|
|
api_cmd_list.append(api_cmd_payload_reason)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_list),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def lock_host(token, host_uuid):
|
|
"""
|
|
Ask System Inventory to lock a host
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
host_data = dict()
|
|
host_data['path'] = "/action"
|
|
host_data['value'] = "lock"
|
|
host_data['op'] = "replace"
|
|
|
|
api_cmd_payload = list()
|
|
api_cmd_payload.append(host_data)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def unlock_host(token, host_uuid):
|
|
"""
|
|
Ask System Inventory to unlock a host
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
host_data = dict()
|
|
host_data['path'] = "/action"
|
|
host_data['value'] = "unlock"
|
|
host_data['op'] = "replace"
|
|
|
|
api_cmd_payload = list()
|
|
api_cmd_payload.append(host_data)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def reboot_host(token, host_uuid):
|
|
"""
|
|
Ask System Inventory to reboot a host
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
host_data = dict()
|
|
host_data['path'] = "/action"
|
|
host_data['value'] = "reboot"
|
|
host_data['op'] = "replace"
|
|
|
|
api_cmd_payload = list()
|
|
api_cmd_payload.append(host_data)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def upgrade_host(token, host_uuid):
|
|
"""
|
|
Ask System Inventory to upgrade a host
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/upgrade" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
api_cmd_payload['force'] = "false"
|
|
|
|
response = rest_api_request(token, "POST", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def swact_from_host(token, host_uuid):
|
|
"""
|
|
Ask System Inventory to swact from a host
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
host_data = dict()
|
|
host_data['path'] = "/action"
|
|
host_data['value'] = "swact"
|
|
host_data['op'] = "replace"
|
|
|
|
api_cmd_payload = list()
|
|
api_cmd_payload.append(host_data)
|
|
|
|
response = rest_api_request(token, "PATCH", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_host_devices(token, host_uuid):
|
|
"""
|
|
Asks System Inventory for host device details
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/pci_devices" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd, api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def get_host_device(token, device_uuid):
|
|
"""
|
|
Asks System Inventory for host details for specific device
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/pci_devices/%s" % device_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
response = rest_api_request(token, "GET", api_cmd, api_cmd_headers,
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def host_device_image_update(token, host_uuid):
|
|
"""
|
|
Asks System Inventory to start a host device image update
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/device_image_update" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
|
|
response = rest_api_request(token, "POST", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|
|
|
|
|
|
def host_device_image_update_abort(token, host_uuid):
|
|
"""
|
|
Asks System Inventory to abort a host device image update
|
|
"""
|
|
url = token.get_service_url(PLATFORM_SERVICE.SYSINV)
|
|
if url is None:
|
|
raise ValueError("OpenStack SysInv URL is invalid")
|
|
|
|
api_cmd = url + "/ihosts/%s/device_image_update_abort" % host_uuid
|
|
|
|
api_cmd_headers = dict()
|
|
api_cmd_headers['Content-Type'] = "application/json"
|
|
api_cmd_headers['User-Agent'] = "vim/1.0"
|
|
|
|
api_cmd_payload = dict()
|
|
|
|
response = rest_api_request(token, "POST", api_cmd, api_cmd_headers,
|
|
json.dumps(api_cmd_payload),
|
|
timeout_in_secs=REST_API_REQUEST_TIMEOUT)
|
|
return response
|