776 lines
27 KiB
Python
Executable File
776 lines
27 KiB
Python
Executable File
#
|
|
# Copyright (c) 2015-2016 Wind River Systems, Inc.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
import six
|
|
|
|
from nfv_common import debug
|
|
from nfv_common.helpers import coroutine
|
|
from nfv_common.helpers import Singleton
|
|
|
|
from nfv_vim import nfvi
|
|
from nfv_vim import objects
|
|
from nfv_vim import tables
|
|
|
|
from nfv_vim.directors._directors_defs import Operation
|
|
from nfv_vim.directors._directors_defs import OPERATION_STATE
|
|
from nfv_vim.directors._directors_defs import OPERATION_TYPE
|
|
|
|
DLOG = debug.debug_get_logger('nfv_vim.host_director')
|
|
|
|
_host_director = None
|
|
|
|
|
|
@six.add_metaclass(Singleton)
|
|
class HostDirector(object):
|
|
"""
|
|
Host Director
|
|
"""
|
|
def __init__(self):
|
|
self._host_operation = None
|
|
|
|
@coroutine
|
|
def _nfvi_lock_host_callback(self):
|
|
"""
|
|
NFVI Lock Host Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Lock Host callback response=%s." % response)
|
|
if not response['completed']:
|
|
DLOG.info("Lock of host %s failed, reason=%s."
|
|
% (response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.LOCK_HOSTS != self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name, self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_lock_failed(host)
|
|
|
|
def _nfvi_lock_host(self, host_uuid, host_name):
|
|
"""
|
|
NFVI Lock Host
|
|
"""
|
|
nfvi.nfvi_lock_host(host_uuid, host_name, self._nfvi_lock_host_callback())
|
|
|
|
@coroutine
|
|
def _nfvi_disable_host_services_callback(self, service):
|
|
"""
|
|
NFVI Disable Host Services Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Disable Host %s Services callback "
|
|
"response=%s." % (service, response))
|
|
if not response['completed']:
|
|
DLOG.info("Disable of %s services on host %s failed"
|
|
", reason=%s."
|
|
% (service, response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.DISABLE_HOST_SERVICES != \
|
|
self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name, self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.disable_host_services_failed(host)
|
|
|
|
def _nfvi_disable_host_services(self, host_uuid, host_name,
|
|
host_personality, service):
|
|
"""
|
|
NFVI Disable Host Services
|
|
"""
|
|
if service == objects.HOST_SERVICES.COMPUTE:
|
|
nfvi.nfvi_disable_compute_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_disable_host_services_callback(
|
|
objects.HOST_SERVICES.COMPUTE))
|
|
elif service == objects.HOST_SERVICES.GUEST:
|
|
nfvi.nfvi_disable_guest_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_disable_host_services_callback(
|
|
objects.HOST_SERVICES.GUEST))
|
|
elif service == objects.HOST_SERVICES.CONTAINER:
|
|
nfvi.nfvi_disable_container_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_disable_host_services_callback(
|
|
objects.HOST_SERVICES.CONTAINER))
|
|
else:
|
|
DLOG.error("Trying to disable unknown service: %s" % service)
|
|
|
|
@coroutine
|
|
def _nfvi_enable_host_services_callback(self, service):
|
|
"""
|
|
NFVI Enable Host Services Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Enable Host %s Services callback "
|
|
"response=%s." % (service, response))
|
|
if not response['completed']:
|
|
DLOG.info("Enable of %s services on host %s failed, reason=%s."
|
|
% (service, response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.ENABLE_HOST_SERVICES != \
|
|
self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name,
|
|
self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.enable_host_services_failed(host)
|
|
|
|
def _nfvi_enable_host_services(self, host_uuid, host_name,
|
|
host_personality, service):
|
|
"""
|
|
NFVI Enable Host Services
|
|
"""
|
|
if service == objects.HOST_SERVICES.COMPUTE:
|
|
nfvi.nfvi_enable_compute_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_enable_host_services_callback(
|
|
objects.HOST_SERVICES.COMPUTE))
|
|
elif service == objects.HOST_SERVICES.GUEST:
|
|
nfvi.nfvi_enable_guest_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_enable_host_services_callback(
|
|
objects.HOST_SERVICES.GUEST))
|
|
elif service == objects.HOST_SERVICES.CONTAINER:
|
|
nfvi.nfvi_enable_container_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_enable_host_services_callback(
|
|
objects.HOST_SERVICES.CONTAINER))
|
|
elif service == objects.HOST_SERVICES.NETWORK:
|
|
nfvi.nfvi_enable_network_host_services(
|
|
host_uuid, host_name, host_personality,
|
|
self._nfvi_enable_host_services_callback(
|
|
objects.HOST_SERVICES.NETWORK))
|
|
else:
|
|
DLOG.error("Trying to enable unknown service: %s" % service)
|
|
|
|
@coroutine
|
|
def _nfvi_unlock_host_callback(self):
|
|
"""
|
|
NFVI Unlock Host Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Unlock Host callback response=%s." % response)
|
|
if not response['completed']:
|
|
DLOG.info("Unlock of host %s failed, reason=%s."
|
|
% (response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.UNLOCK_HOSTS != self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name, self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_unlock_failed(host)
|
|
|
|
def _nfvi_unlock_host(self, host_uuid, host_name):
|
|
"""
|
|
NFVI Unlock Host
|
|
"""
|
|
nfvi.nfvi_unlock_host(host_uuid, host_name,
|
|
self._nfvi_unlock_host_callback())
|
|
|
|
@coroutine
|
|
def _nfvi_reboot_host_callback(self):
|
|
"""
|
|
NFVI Reboot Host Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Reboot Host callback response=%s." % response)
|
|
if not response['completed']:
|
|
DLOG.info("Reboot of host %s failed, reason=%s."
|
|
% (response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.REBOOT_HOSTS != self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name, self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_reboot_failed(host)
|
|
|
|
def _nfvi_reboot_host(self, host_uuid, host_name):
|
|
"""
|
|
NFVI Reboot Host
|
|
"""
|
|
nfvi.nfvi_reboot_host(host_uuid, host_name,
|
|
self._nfvi_reboot_host_callback())
|
|
|
|
@coroutine
|
|
def _nfvi_upgrade_host_callback(self):
|
|
"""
|
|
NFVI Upgrade Host Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Upgrade Host callback response=%s." % response)
|
|
if not response['completed']:
|
|
DLOG.info("Upgrade of host %s failed, reason=%s."
|
|
% (response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.UPGRADE_HOSTS != self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name, self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_upgrade_failed(host)
|
|
|
|
def _nfvi_upgrade_host(self, host_uuid, host_name):
|
|
"""
|
|
NFVI Upgrade Host
|
|
"""
|
|
nfvi.nfvi_upgrade_host(host_uuid, host_name,
|
|
self._nfvi_upgrade_host_callback())
|
|
|
|
@coroutine
|
|
def _nfvi_swact_host_callback(self):
|
|
"""
|
|
NFVI Swact Host Callback
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
response = (yield)
|
|
DLOG.verbose("NFVI Swact Host callback response=%s." % response)
|
|
if not response['completed']:
|
|
DLOG.info("Swact of host %s failed, reason=%s."
|
|
% (response['host_name'], response['reason']))
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host = host_table.get(response['host_name'], None)
|
|
if host is None:
|
|
DLOG.verbose("Host %s does not exist." % response['host_name'])
|
|
return
|
|
|
|
if self._host_operation is None:
|
|
DLOG.verbose("No host %s operation inprogress." % host.name)
|
|
return
|
|
|
|
if OPERATION_TYPE.SWACT_HOSTS != self._host_operation.operation_type:
|
|
DLOG.verbose("Unexpected host %s operation %s, ignoring."
|
|
% (host.name, self._host_operation.operation_type))
|
|
return
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_swact_failed(host)
|
|
|
|
def _nfvi_swact_host(self, host_uuid, host_name):
|
|
"""
|
|
NFVI Swact Host
|
|
"""
|
|
nfvi.nfvi_swact_from_host(host_uuid, host_name,
|
|
self._nfvi_swact_host_callback())
|
|
|
|
def host_operation_inprogress(self):
|
|
"""
|
|
Returns true if a lock of hosts
|
|
"""
|
|
if self._host_operation is not None:
|
|
return self._host_operation.is_inprogress()
|
|
return False
|
|
|
|
@staticmethod
|
|
def host_has_instances(host, skip_stopped=False):
|
|
"""
|
|
Returns true if a host has instances located on it
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
instance_director = directors.get_instance_director()
|
|
return instance_director.host_has_instances(host, skip_stopped=skip_stopped)
|
|
|
|
@staticmethod
|
|
def host_instances_moved(host, host_operation):
|
|
"""
|
|
Notifies the host director that all the instances have been moved from
|
|
a host
|
|
"""
|
|
host.notify_instances_moved(host_operation)
|
|
|
|
@staticmethod
|
|
def host_instances_stopped(host, host_operation):
|
|
"""
|
|
Notifies the host director that all the instances have been stopped on
|
|
a host
|
|
"""
|
|
host.notify_instances_stopped(host_operation)
|
|
|
|
@staticmethod
|
|
def host_enabled(host):
|
|
"""
|
|
Notifies the host director that a host is enabled
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Notify other directors that the host %s is enabled."
|
|
% host.name)
|
|
instance_director = directors.get_instance_director()
|
|
instance_director.recover_instances()
|
|
|
|
@staticmethod
|
|
def host_services_disabling(host):
|
|
"""
|
|
Notifies the host director that host services are being disabled
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Notify other directors that the host %s services are "
|
|
"disabling." % host.name)
|
|
instance_director = directors.get_instance_director()
|
|
host_operation = instance_director.host_services_disabling(host)
|
|
return host_operation
|
|
|
|
@staticmethod
|
|
def host_services_disabled(host):
|
|
"""
|
|
Notifies the host director that host services are disabled
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Notify other directors that the host %s services are "
|
|
"disabled." % host.name)
|
|
instance_director = directors.get_instance_director()
|
|
host_operation = instance_director.host_services_disabled(host)
|
|
return host_operation
|
|
|
|
@staticmethod
|
|
def host_disabled(host):
|
|
"""
|
|
Notifies the host director that a host is disabled
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Notify other directors that the host %s is disabled."
|
|
% host.name)
|
|
|
|
instance_director = directors.get_instance_director()
|
|
instance_director.host_disabled(host)
|
|
|
|
@staticmethod
|
|
def host_offline(host):
|
|
"""
|
|
Notifies the host director that a host is offline
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Notify other directors that the host %s is offline."
|
|
% host.name)
|
|
instance_director = directors.get_instance_director()
|
|
instance_director.host_offline(host)
|
|
# Now that the host is offline, we may be able to recover instances
|
|
# on that host (i.e. evacuate them).
|
|
instance_director.recover_instances()
|
|
|
|
@staticmethod
|
|
def host_audit(host):
|
|
"""
|
|
Notifies the host director that a host audit is inprogress
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.verbose("Notify other directors that a host %s audit is inprogress."
|
|
% host.name)
|
|
instance_director = directors.get_instance_director()
|
|
instance_director.host_audit(host)
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_audit(host)
|
|
|
|
@staticmethod
|
|
def host_abort(host):
|
|
"""
|
|
Notifies the host director that a host abort is inprogress
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Notify other directors that a host %s abort is inprogress."
|
|
% host.name)
|
|
instance_director = directors.get_instance_director()
|
|
instance_director.host_operation_cancel(host.name)
|
|
|
|
@staticmethod
|
|
def host_state_change_notify(host):
|
|
"""
|
|
Notifies the host director that a host has changed state
|
|
"""
|
|
from nfv_vim import directors
|
|
|
|
DLOG.info("Host %s state change notification." % host.name)
|
|
|
|
sw_mgmt_director = directors.get_sw_mgmt_director()
|
|
sw_mgmt_director.host_state_change(host)
|
|
|
|
def lock_hosts(self, host_names):
|
|
"""
|
|
Lock a list of hosts
|
|
"""
|
|
DLOG.info("Lock hosts: %s" % host_names)
|
|
|
|
host_operation = Operation(OPERATION_TYPE.LOCK_HOSTS)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
if host.is_locking():
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
|
|
elif host.is_locked():
|
|
host_operation.add_host(host.name, OPERATION_STATE.COMPLETED)
|
|
|
|
else:
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
self._nfvi_lock_host(host.uuid, host.name)
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
def unlock_hosts(self, host_names):
|
|
"""
|
|
Unlock a list of hosts
|
|
"""
|
|
DLOG.info("Unlock hosts: %s" % host_names)
|
|
|
|
host_operation = Operation(OPERATION_TYPE.UNLOCK_HOSTS)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
if host.is_locked():
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
self._nfvi_unlock_host(host.uuid, host.name)
|
|
|
|
elif host.is_unlocking():
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
|
|
else:
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
def reboot_hosts(self, host_names):
|
|
"""
|
|
Reboot a list of hosts
|
|
"""
|
|
DLOG.info("Reboot hosts: %s" % host_names)
|
|
|
|
host_operation = Operation(OPERATION_TYPE.REBOOT_HOSTS)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
if host.is_locked():
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
self._nfvi_reboot_host(host.uuid, host.name)
|
|
|
|
else:
|
|
reason = "Cannot reboot unlocked host %s." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
def upgrade_hosts(self, host_names):
|
|
"""
|
|
Upgrade a list of hosts
|
|
"""
|
|
DLOG.info("Upgrade hosts: %s" % host_names)
|
|
|
|
host_operation = Operation(OPERATION_TYPE.UPGRADE_HOSTS)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
if host.is_locked():
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
self._nfvi_upgrade_host(host.uuid, host.name)
|
|
|
|
else:
|
|
reason = "Cannot upgrade unlocked host %s." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
def swact_hosts(self, host_names):
|
|
"""
|
|
Swact a list of hosts
|
|
"""
|
|
DLOG.info("Swact hosts: %s" % host_names)
|
|
|
|
host_operation = Operation(OPERATION_TYPE.SWACT_HOSTS)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
self._nfvi_swact_host(host.uuid, host.name)
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
def disable_host_services(self, host_names, service):
|
|
"""
|
|
Disable a host service on a list of hosts
|
|
"""
|
|
DLOG.info("Disable host services: %s service: %s" %
|
|
(host_names, service))
|
|
|
|
host_operation = Operation(OPERATION_TYPE.DISABLE_HOST_SERVICES)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host_list = list()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
host.host_services_locked = True
|
|
if (objects.HOST_SERVICE_STATE.DISABLED ==
|
|
host.host_service_state(service)):
|
|
host_operation.add_host(host.name, OPERATION_STATE.COMPLETED)
|
|
else:
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
host_list.append(host)
|
|
|
|
for host in host_list:
|
|
self._nfvi_disable_host_services(
|
|
host.uuid, host.name, host.personality, service)
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
def enable_host_services(self, host_names, service):
|
|
"""
|
|
Enable a host service on a list of hosts
|
|
"""
|
|
DLOG.info("Enable host services: %s service: %s" %
|
|
(host_names, service))
|
|
|
|
host_operation = Operation(OPERATION_TYPE.ENABLE_HOST_SERVICES)
|
|
|
|
if self._host_operation is not None:
|
|
DLOG.debug("Canceling previous host operation %s, before "
|
|
"continuing with host operation %s."
|
|
% (self._host_operation.operation_type,
|
|
host_operation.operation_type))
|
|
self._host_operation = None
|
|
|
|
host_table = tables.tables_get_host_table()
|
|
host_list = list()
|
|
for host_name in host_names:
|
|
host = host_table.get(host_name, None)
|
|
if host is None:
|
|
reason = "Unknown host %s given." % host_name
|
|
DLOG.info(reason)
|
|
host_operation.set_failed(reason)
|
|
return host_operation
|
|
|
|
host.host_services_locked = False
|
|
if (objects.HOST_SERVICE_STATE.ENABLED ==
|
|
host.host_service_state(service)):
|
|
host_operation.add_host(host.name, OPERATION_STATE.COMPLETED)
|
|
else:
|
|
host_operation.add_host(host.name, OPERATION_STATE.INPROGRESS)
|
|
host_list.append(host)
|
|
|
|
for host in host_list:
|
|
self._nfvi_enable_host_services(
|
|
host.uuid, host.name, host.personality, service)
|
|
|
|
if host_operation.is_inprogress():
|
|
self._host_operation = host_operation
|
|
|
|
return host_operation
|
|
|
|
|
|
def get_host_director():
|
|
"""
|
|
Returns the Host Director
|
|
"""
|
|
return _host_director
|
|
|
|
|
|
def host_director_initialize():
|
|
"""
|
|
Initialize Host Director
|
|
"""
|
|
global _host_director
|
|
|
|
_host_director = HostDirector()
|
|
|
|
|
|
def host_director_finalize():
|
|
"""
|
|
Finalize Host Director
|
|
"""
|
|
pass
|