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()