def setUp(self, connect, update, creds):
creds.return_value = ["username", "password"]
self.vim_client = VimClient(auto_sync=False)
self.vim_client.wait_for_task = MagicMock()
self.patcher = patch("host.hypervisor.esx.vm_config.GetEnv")
self.patcher.start()
self.vm_manager = EsxVmManager(self.vim_client, MagicMock())
def setUp(self):
if "host_remote_test" not in config:
raise SkipTest()
self.host = config["host_remote_test"]["server"]
self.pwd = config["host_remote_test"]["esx_pwd"]
self.agent_port = config["host_remote_test"].get("agent_port", 8835)
if self.host is None or self.pwd is None:
raise SkipTest()
self.image_datastore = config["host_remote_test"].get(
"image_datastore", "datastore1")
self._logger = logging.getLogger(__name__)
self.vim_client = VimClient(self.host, "root", self.pwd)
self.http_transferer = HttpNfcTransferer(self.vim_client,
[self.image_datastore],
self.host)
with tempfile.NamedTemporaryFile(delete=False) as source_file:
with open(source_file.name, 'wb') as f:
f.write(os.urandom(1024 * 100))
self.random_file = source_file.name
self.remote_files_to_delete = []
def setUp(self):
self.vim_client = VimClient(auto_sync=False)
self.vim_client._content = MagicMock()
self.vim_client.wait_for_task = MagicMock()
self.disk_manager = DiskManager(self.vim_client, [])
self.disk_manager._vmdk_mkdir = MagicMock()
self.disk_manager._vmdk_rmdir = MagicMock()
def test_update_fail_without_looping(self, connect_mock, update_mock):
client = VimClient(auto_sync=True, min_interval=1)
client.connect_userpwd("esx.local", "root", "password")
update_mock.side_effect = vim.fault.HostConnectFault
time.sleep(0.5)
client.disconnect()
assert_that(update_mock.call_count, less_than(5)) # no crazy loop
def setUp(self, connect, update, creds):
creds.return_value = ["username", "password"]
self.vim_client = VimClient(auto_sync=False)
self.vim_client.wait_for_task = MagicMock()
self.disk_manager = EsxDiskManager(self.vim_client, [])
self.disk_manager._vmdk_mkdir = MagicMock()
self.disk_manager._vmdk_rmdir = MagicMock()
def test_acquire_credentials(self, si_method_mock):
"""The mockery of acquiring local hostd credentials"""
local_ticket_mock = MagicMock(name="local_ticket")
type(local_ticket_mock).userName = PropertyMock(
return_value="local-root")
pwd_fd, pwd_path = tempfile.mkstemp()
os.write(pwd_fd, "local-root-password")
os.close(pwd_fd)
type(local_ticket_mock).passwordFilePath = PropertyMock(
return_value=pwd_path)
session_manager_mock = MagicMock(name="session-manager")
session_manager_mock.AcquireLocalTicket.return_value = local_ticket_mock
si = MagicMock(name="si")
session_manager_property = PropertyMock(
return_value=session_manager_mock)
type(si.content).sessionManager = session_manager_property
si_method_mock.return_value = si
vim_client = VimClient(auto_sync=False)
(user, password) = vim_client._acquire_local_credentials()
os.remove(pwd_path)
assert_that(user, equal_to("local-root"))
assert_that(password, equal_to("local-root-password"))
def test_vim_client_with_param(self, connect_mock):
vim_client = VimClient(auto_sync=False)
vim_client.connect_userpwd("esx.local", "root", "password")
connect_mock.assert_called_once_with(host="esx.local",
user="******",
pwd="password",
version="vim.version.version9")
def test_update_host_cache_in_thread(self, disconnect_mock, connect_mock,
spec_mock, update_mock,
prop_collector_mock):
vm = vim.VirtualMachine("moid", None)
vm.kind = "enter"
vm.changeSet = {}
update = MagicMock()
update.filterSet = [MagicMock()]
update.filterSet[0].objectSet = [MagicMock()]
update.filterSet[0].objectSet[0] = vm
# Mock the Vim APIs.
prop_collector_mock.WaitForUpdatesEx = MagicMock()
prop_collector_mock.WaitForUpdatesEx.return_value = update
# Create VimClient.
vim_client = VimClient(min_interval=0.1, auto_sync=True)
vim_client.connect_userpwd("esx.local", "root", "password")
# Verify that the update mock is called a few times.
retry = 0
while update_mock.call_count < 5 and retry < 10:
time.sleep(0.2)
retry += 1
assert_that(retry, is_not(10),
"VimClient.update_mock is not called repeatedly")
# Disconnect the client and stop the thread.
vim_client.disconnect()
assert_that(disconnect_mock.called, is_(True))
assert_that(update_mock.call_count, is_not(0),
"VimClient.update_mock is not called")
def __init__(self, agent_config):
self.logger = logging.getLogger(__name__)
# If VimClient's housekeeping thread failed to update its own cache,
# call errback to commit suicide. Watchdog will bring up the agent
# again.
self.vim_client = VimClient(wait_timeout=agent_config.wait_timeout,
errback=lambda: suicide())
atexit.register(lambda client: client.disconnect(), self.vim_client)
self._uuid = self.vim_client.host_uuid
self.set_memory_overcommit(agent_config.memory_overcommit)
self.datastore_manager = EsxDatastoreManager(
self, agent_config.datastores, agent_config.image_datastores)
# datastore manager needs to update the cache when there is a change.
self.vim_client.add_update_listener(self.datastore_manager)
self.vm_manager = EsxVmManager(self.vim_client, self.datastore_manager)
self.disk_manager = EsxDiskManager(self.vim_client,
self.datastore_manager)
self.image_manager = EsxImageManager(self.vim_client,
self.datastore_manager)
self.network_manager = EsxNetworkManager(self.vim_client,
agent_config.networks)
self.system = EsxSystem(self.vim_client)
self.image_manager.monitor_for_cleanup()
self.image_transferer = HttpNfcTransferer(
self.vim_client, self.datastore_manager.image_datastores())
atexit.register(self.image_manager.cleanup)
def test_update_fail_will_suicide(self, sleep_mock, connect_mock,
update_mock, update_hosts_mock):
killed = threading.Event()
def suicide():
killed.set()
threading.current_thread().stop()
update_cache = MagicMock()
update_cache.side_effect = vim.fault.HostConnectFault
client = VimClient("esx.local",
"root",
"password",
auto_sync=True,
min_interval=1,
errback=lambda: suicide())
client.update_cache = update_cache
killed.wait(1)
client.disconnect(wait=True)
# update_cache will be called 5 times before it kill itself
assert_that(update_cache.call_count, is_(5))
assert_that(killed.is_set(), is_(True))
def test_update_host_cache_in_thread(self, disconnect_mock, connect_mock,
spec_mock, update_mock,
update_host_mock, query_spec_mock,
perf_manager_mock,
prop_collector_mock):
# Test Values.
counter = MagicMock()
counter.groupInfo.key = "mem"
counter.nameInfo.key = "consumed"
counter.key = 65613
n = 5
statValues = ','.join([str(x) for x in range(1, n + 1)])
statAverage = sum(range(1, n + 1)) / len(range(1, n + 1))
stat = MagicMock()
stat.value = [MagicMock()]
stat.value[0].id.counterId = 65613
stat.value[0].value = statValues
# Mock the Vim APIs.
pc_return_mock = MagicMock({'WaitForUpdatesEx.return_value': {}})
summarize_stats = {'QueryPerf.return_value': [stat]}
pm_return_mock = MagicMock(perfCounter=[counter], **summarize_stats)
# Tie the mocked APIs with VimClient.
prop_collector_mock.return_value = pc_return_mock
perf_manager_mock.return_value = pm_return_mock
# Create VimClient.
vim_client = VimClient("esx.local",
"root",
"password",
min_interval=0.1,
auto_sync=True,
stats_interval=0.2)
# Verify that the update mock is called a few times.
retry = 0
while update_mock.call_count < 5 and retry < 10:
time.sleep(0.2)
retry += 1
assert_that(retry, is_not(10), "VimClient.update_mock is not "
"called repeatedly")
# Disconnect the client and stop the thread.
vim_client.disconnect(wait=True)
assert_that(disconnect_mock.called, is_(True))
# Verify that update_host_mock is called atleast once and is called
# less number of times than update_mock.
assert_that(update_host_mock.call_count, is_not(0),
"VimClient.update_host_mock is not called repeatedly")
assert_that(update_host_mock.call_count,
less_than(update_mock.call_count))
host_stats = update_host_mock.call_args_list
for host in host_stats:
assert_that(host[0][0]['mem.consumed'], equal_to(statAverage))
def create_host_client(auto_sync=True, errback=None):
try:
# check whether attache is installed. If not, find_module will throw ImportError.
from host.hypervisor.esx.attache_client import AttacheClient
return AttacheClient(auto_sync, errback)
except ImportError:
from host.hypervisor.esx.vim_client import VimClient
return VimClient(auto_sync, errback)
def test_acquire_credentials_connection_failure(self, si_method_mock):
si = MagicMock(name="si")
session_manager_property = PropertyMock(
side_effect=HTTPException("hubba"))
type(si.content).sessionManager = session_manager_property
si_method_mock.return_value = si
vim_client = VimClient(auto_sync=False)
self.assertRaises(AcquireCredentialsException,
vim_client._acquire_local_credentials)
def setUp(self, connect, creds):
self.shadow_vm_id = SHADOW_VM_NAME_PREFIX + str(uuid.uuid4())
self.image_datastores = ["image_ds", "alt_image_ds"]
creds.return_value = ["username", "password"]
self.vim_client = VimClient(auto_sync=False)
self.patcher = patch("host.hypervisor.esx.vm_config.GetEnv")
self.patcher.start()
services.register(ServiceName.AGENT_CONFIG, MagicMock())
self.http_transferer = HttpNfcTransferer(self.vim_client,
self.image_datastores)
def _create_remote_vim_client(self, agent_client, host):
request = ServiceTicketRequest(service_type=ServiceType.VIM)
response = agent_client.get_service_ticket(request)
if response.result != ServiceTicketResultCode.OK:
self._logger.info("Get service ticket failed. Response = %s" %
str(response))
raise ValueError("No ticket")
vim_client = VimClient(host=host,
ticket=response.vim_ticket,
auto_sync=False)
return vim_client
def _get_remote_connections(self, host, port):
agent_client = DirectClient("Host", Host.Client, host, port)
agent_client.connect()
request = ServiceTicketRequest(service_type=ServiceType.VIM)
response = agent_client.get_service_ticket(request)
if response.result != ServiceTicketResultCode.OK:
self._logger.info("Get service ticket failed. Response = %s" %
str(response))
raise ValueError("No ticket")
vim_client = VimClient(
host=host, ticket=response.vim_ticket, auto_sync=False)
return agent_client, vim_client
def test_vim_client_with_param(self, connect_mock, update_mock):
vim_client = VimClient("esx.local",
"root",
"password",
auto_sync=False)
assert_that(vim_client.host, is_("esx.local"))
assert_that(vim_client.username, is_("root"))
assert_that(vim_client.password, is_("password"))
connect_mock.assert_called_once_with(host="esx.local",
user="******",
pwd="password",
version="vim.version.version9")
def setUp(self):
if "host_remote_test" not in config:
raise SkipTest()
self.host = config["host_remote_test"]["server"]
self.pwd = config["host_remote_test"]["esx_pwd"]
if self.host is None or self.pwd is None:
raise SkipTest()
self.vim_client = VimClient(auto_sync=True)
self.vim_client.connect_userpwd(self.host, "root", self.pwd)
self._logger = logging.getLogger(__name__)
def setUp(self):
self.vim_client = VimClient(auto_sync=False)
self.vim_client._content = MagicMock()
self.host = MagicMock(spec=vim.ManagedObject,
key=vim.HostSystem("ha-host"))
self.host.summary = MagicMock()
self.host.summary.quickStats = MagicMock()
self.host.summary.hardware = MagicMock()
self.host.summary.quickStats.overallCpuUsage = 1024
self.host.summary.hardware.cpuMhz = 1024
self.host.summary.hardware.numCpuCores = 2
self.host.summary.quickStats.overallMemoryUsage = 2 # 2GB
self.host.summary.hardware.memorySize = 4 * 1024 * 1024 # 4GB
self.vim_client.host_system = MagicMock(return_value=self.host)
def setUp(self):
# Create VM manager
self.vim_client = VimClient(auto_sync=False)
self.vim_client._content = MagicMock()
self.vim_client.wait_for_task = MagicMock()
self.vm_manager = VmManager(self.vim_client, MagicMock())
services.register(ServiceName.AGENT_CONFIG, MagicMock())
# Set up test files
self.base_dir = os.path.dirname(__file__)
self.test_dir = os.path.join(self.base_dir, "../test_files")
self.image_manager = ImageManager(MagicMock(), MagicMock())
self.image_scanner = DatastoreImageScanner(self.image_manager, self.vm_manager, self.DATASTORE_ID)
self.write_count = 0
def setUp(self):
if "host_remote_test" not in config:
raise SkipTest()
self.host = config["host_remote_test"]["server"]
self.pwd = config["host_remote_test"]["esx_pwd"]
if self.host is None or self.pwd is None:
raise SkipTest()
self._logger = logging.getLogger(__name__)
self.vim_client = VimClient(self.host, "root", self.pwd)
self.vm_manager = EsxVmManager(self.vim_client, [])
for vm in self.vim_client.get_vms():
vm.Destroy()
def test_poll_update_in_thread(self, disconnect_mock, connect_mock,
spec_mock, update_mock):
vim_client = VimClient(min_interval=0, auto_sync=True)
vim_client.connect_userpwd("esx.local", "root", "password")
vim_client._property_collector.WaitForUpdatesEx.return_value = {}
assert_that(update_mock.called, is_(True))
retry = 0
while update_mock.call_count < 5 and retry < 10:
time.sleep(0.2)
retry += 1
assert_that(retry, is_not(10),
"VimClient._poll_updates is not called repeatedly")
vim_client.disconnect()
assert_that(disconnect_mock.called, is_(True))
def test_get_nfc_ticket(self, connect_mock):
vim_client = VimClient(auto_sync=False)
vim_client._find_by_inventory_path = MagicMock(return_value=None)
self.assertRaises(DatastoreNotFound,
vim_client.get_nfc_ticket_by_ds_name, "no_exist")
ds_mock = MagicMock()
vim_client._find_by_inventory_path = MagicMock(return_value=ds_mock)
nfc_service = MagicMock()
type(vim).NfcService = MagicMock()
type(vim).NfcService.return_value = nfc_service
vim_client._si = MagicMock()
vim_client.get_nfc_ticket_by_ds_name("existing_ds")
nfc_service.FileManagement.assert_called_once_with(ds_mock)
def setUp(self, connect, update, creds):
# Create VM manager
creds.return_value = ["username", "password"]
self.vim_client = VimClient(auto_sync=False)
self.vim_client.wait_for_task = MagicMock()
self.patcher = patch("host.hypervisor.esx.vm_config.GetEnv")
self.patcher.start()
self.vm_manager = EsxVmManager(self.vim_client, MagicMock())
services.register(ServiceName.AGENT_CONFIG, MagicMock())
# Set up test files
self.base_dir = os.path.dirname(__file__)
self.test_dir = os.path.join(self.base_dir, "../../test_files")
self.image_manager = EsxImageManager(MagicMock(), MagicMock())
self.image_scanner = DatastoreImageScanner(self.image_manager,
self.vm_manager,
self.DATASTORE_ID)
self.write_count = 0
def test_vim_client_errback(self, connect_mock, host_mock):
callback = MagicMock()
vim_client = VimClient(auto_sync=False, errback=callback)
vim_client.connect_userpwd("esx.local", "root", "password")
host_mock.side_effect = vim.fault.NotAuthenticated
vim_client.host_system()
callback.assert_called_once()
host_mock.side_effect = vim.fault.HostConnectFault
vim_client.host_system()
assert_that(callback.call_count, is_(2))
host_mock.side_effect = vim.fault.InvalidLogin
vim_client.host_system()
assert_that(callback.call_count, is_(3))
host_mock.side_effect = AcquireCredentialsException
vim_client.host_system()
assert_that(callback.call_count, is_(4))
def __init__(self, agent_config):
self.logger = logging.getLogger(__name__)
# If VimClient's housekeeping thread failed to update its own cache,
# call errback to commit suicide. Watchdog will bring up the agent
# again.
errback = lambda: suicide()
self.vim_client = VimClient(wait_timeout=agent_config.wait_timeout,
errback=errback)
atexit.register(lambda client: client.disconnect(), self.vim_client)
self._uuid = self.vim_client.host_uuid
# Enable/Disable large page support. If this host is removed
# from the deployment, large page support will need to be
# explicitly updated by the user.
disable_large_pages = agent_config.memory_overcommit > 1.0
self.vim_client.set_large_page_support(disable=disable_large_pages)
image_datastores = [ds["name"] for ds in agent_config.image_datastores]
self.datastore_manager = EsxDatastoreManager(self,
agent_config.datastores,
image_datastores)
# datastore manager needs to update the cache when there is a change.
self.vim_client.add_update_listener(self.datastore_manager)
self.vm_manager = EsxVmManager(self.vim_client, self.datastore_manager)
self.disk_manager = EsxDiskManager(self.vim_client,
self.datastore_manager)
self.image_manager = EsxImageManager(self.vim_client,
self.datastore_manager)
self.network_manager = EsxNetworkManager(self.vim_client,
agent_config.networks)
self.system = EsxSystem(self.vim_client)
self.image_manager.monitor_for_cleanup()
self.image_transferer = HttpNfcTransferer(self.vim_client,
image_datastores)
atexit.register(self.image_manager.cleanup)
def setUp(self, connect, update, creds):
creds.return_value = ["username", "password"]
self.vim_client = VimClient(auto_sync=False)
with patch("host.hypervisor.esx.vm_config.GetEnv"):
self.vm_config = EsxVmConfig(self.vim_client)
def setUp(self):
self.vim_client = VimClient(auto_sync=False)
self.vim_client._content = MagicMock()
self.ds_manager = MagicMock()
services.register(ServiceName.AGENT_CONFIG, MagicMock())
self.image_manager = ImageManager(self.vim_client, self.ds_manager)
def setUp(self, connect, update, creds):
creds.return_value = ["username", "password"]
self.vim_client = VimClient(auto_sync=False)
self.ds_manager = MagicMock()
services.register(ServiceName.AGENT_CONFIG, MagicMock())
self.image_manager = EsxImageManager(self.vim_client, self.ds_manager)
def setUp(self):
self.vim_client = VimClient()
