def test_check_existing_swap_file(self):
test_file = os.path.join(self.tmp_dir, 'test_swap_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
with open(test_file, "wb") as file:
file.write(bytearray(file_size))
os.chmod(test_file, stat.S_ISUID | stat.S_ISGID | stat.S_IRUSR
| stat.S_IWUSR | stat.S_IRWXG | stat.S_IRWXO) # 0o6677
def swap_on(_): # mimic the output of "swapon -s"
return [
"Filename Type Size Used Priority",
"{0} partition 16498684 0 -2".format(test_file)
]
with patch.object(shellutil, "run_get_output", side_effect=swap_on):
get_resourcedisk_handler().check_existing_swap_file(
test_file, test_file, file_size)
# it should remove access from group, others
mode = os.stat(test_file).st_mode & (
stat.S_ISUID | stat.S_ISGID | stat.S_IRWXU | stat.S_IWUSR
| stat.S_IRWXG | stat.S_IRWXO) # 0o6777
assert mode == stat.S_ISUID | stat.S_ISGID | stat.S_IRUSR | stat.S_IWUSR # 0o6600
os.remove(test_file)
def test_check_existing_swap_file(self):
test_file = os.path.join(self.tmp_dir, 'test_swap_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
with open(test_file, "wb") as file:
file.write(bytes(file_size))
os.chmod(test_file, stat.S_ISUID | stat.S_ISGID | stat.S_IRUSR | stat.S_IWUSR | stat.S_IRWXG | stat.S_IRWXO) # 0o6677
def swap_on(_): # mimic the output of "swapon -s"
return [
"Filename Type Size Used Priority",
"{0} partition 16498684 0 -2".format(test_file)
]
with patch.object(shellutil, "run_get_output", side_effect=swap_on):
get_resourcedisk_handler().check_existing_swap_file(test_file, test_file, file_size)
# it should remove access from group, others
mode = os.stat(test_file).st_mode & (stat.S_ISUID | stat.S_ISGID | stat.S_IRWXU | stat.S_IWUSR | stat.S_IRWXG | stat.S_IRWXO) # 0o6777
assert mode == stat.S_ISUID | stat.S_ISGID | stat.S_IRUSR | stat.S_IWUSR # 0o6600
os.remove(test_file)
def test_get_handler(self):
osutil.get_osutil()
protocol.get_protocol_util()
dhcp.get_dhcp_handler()
provision.get_provision_handler()
deprovision.get_deprovision_handler()
daemon.get_daemon_handler()
resourcedisk.get_resourcedisk_handler()
scvmm.get_scvmm_handler()
monitor.get_monitor_handler()
update.get_update_handler()
exthandlers.get_exthandlers_handler()
def test_get_handler(self):
osutil.get_osutil()
protocol.get_protocol_util()
dhcp.get_dhcp_handler()
provision.get_provision_handler()
deprovision.get_deprovision_handler()
daemon.get_daemon_handler()
resourcedisk.get_resourcedisk_handler()
scvmm.get_scvmm_handler()
monitor.get_monitor_handler()
update.get_update_handler()
exthandlers.get_exthandlers_handler()
def test_mkfile(self):
# setup
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
# execute
get_resourcedisk_handler().mkfile(test_file, file_size)
# assert
assert os.path.exists(test_file)
# cleanup
os.remove(test_file)
def test_mkfile(self):
# setup
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
# execute
get_resourcedisk_handler().mkfile(test_file, file_size)
# assert
assert os.path.exists(test_file)
# cleanup
os.remove(test_file)
def daemon(self, child_args=None):
logger.info("Run daemon")
self.protocol_util = get_protocol_util() # pylint: disable=W0201
self.scvmm_handler = get_scvmm_handler() # pylint: disable=W0201
self.resourcedisk_handler = get_resourcedisk_handler() # pylint: disable=W0201
self.rdma_handler = get_rdma_handler() # pylint: disable=W0201
self.provision_handler = get_provision_handler() # pylint: disable=W0201
self.update_handler = get_update_handler() # pylint: disable=W0201
if conf.get_detect_scvmm_env():
self.scvmm_handler.run()
if conf.get_resourcedisk_format():
self.resourcedisk_handler.run()
# Always redetermine the protocol start (e.g., wireserver vs.
# on-premise) since a VHD can move between environments
self.protocol_util.clear_protocol()
self.provision_handler.run()
# Once we have the protocol, complete initialization of the telemetry fields
# that require the goal state and IMDS
self._initialize_telemetry()
# Enable RDMA, continue in errors
if conf.enable_rdma():
nd_version = self.rdma_handler.get_rdma_version()
self.rdma_handler.install_driver_if_needed()
logger.info("RDMA capabilities are enabled in configuration")
try:
# Ensure the most recent SharedConfig is available
# - Changes to RDMA state may not increment the goal state
# incarnation number. A forced update ensures the most
# current values.
protocol = self.protocol_util.get_protocol()
if type(protocol) is not WireProtocol: # pylint: disable=C0123
raise Exception("Attempt to setup RDMA without Wireserver")
protocol.client.update_goal_state(forced=True)
setup_rdma_device(nd_version, protocol.client.get_shared_conf())
except Exception as e: # pylint: disable=C0103
logger.error("Error setting up rdma device: %s" % e)
else:
logger.info("RDMA capabilities are not enabled, skipping")
self.sleep_if_disabled()
# Disable output to /dev/console once provisioning has completed
if logger.console_output_enabled():
logger.info("End of log to /dev/console. The agent will now check for updates and then will process extensions.")
logger.disable_console_output()
while self.running:
self.update_handler.run_latest(child_args=child_args)
def test_mkfile(self):
# setup
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
# execute
get_resourcedisk_handler().mkfile(test_file, file_size)
# assert
assert os.path.exists(test_file)
# only the owner should have access
mode = os.stat(test_file).st_mode & (stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
assert mode == stat.S_IRUSR | stat.S_IWUSR
# cleanup
os.remove(test_file)
def test_mkfile_dd_fallback(self):
with patch.object(shellutil, "run") as run_patch:
# setup
run_patch.return_value = 1
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
# execute
if sys.version_info >= (3,3):
with patch("os.posix_fallocate",
side_effect=Exception('failure')):
get_resourcedisk_handler().mkfile(test_file, file_size)
else:
get_resourcedisk_handler().mkfile(test_file, file_size)
# assert
assert run_patch.call_count > 1
assert "fallocate" in run_patch.call_args_list[0][0][0]
assert "dd if" in run_patch.call_args_list[-1][0][0]
def test_mkfile_dd_fallback(self):
with patch.object(shellutil, "run") as run_patch:
# setup
run_patch.return_value = 1
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
# execute
if sys.version_info >= (3, 3):
with patch("os.posix_fallocate",
side_effect=Exception('failure')):
get_resourcedisk_handler().mkfile(test_file, file_size)
else:
get_resourcedisk_handler().mkfile(test_file, file_size)
# assert
assert run_patch.call_count > 1
assert "fallocate" in run_patch.call_args_list[0][0][0]
assert "dd if" in run_patch.call_args_list[-1][0][0]
def test_mkfile(self):
# setup
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
# execute
get_resourcedisk_handler().mkfile(test_file, file_size)
# assert
assert os.path.exists(test_file)
# only the owner should have access
mode = os.stat(test_file).st_mode & (stat.S_IRWXU | stat.S_IRWXG
| stat.S_IRWXO)
assert mode == stat.S_IRUSR | stat.S_IWUSR
# cleanup
os.remove(test_file)
def daemon(self, child_args=None):
logger.info("Run daemon")
self.protocol_util = get_protocol_util()
self.scvmm_handler = get_scvmm_handler()
self.resourcedisk_handler = get_resourcedisk_handler()
self.rdma_handler = get_rdma_handler()
self.provision_handler = get_provision_handler()
self.update_handler = get_update_handler()
# Create lib dir
if not os.path.isdir(conf.get_lib_dir()):
fileutil.mkdir(conf.get_lib_dir(), mode=0o700)
os.chdir(conf.get_lib_dir())
if conf.get_detect_scvmm_env():
self.scvmm_handler.run()
if conf.get_resourcedisk_format():
self.resourcedisk_handler.run()
# Always redetermine the protocol start (e.g., wireserver vs.
# on-premise) since a VHD can move between environments
self.protocol_util.clear_protocol()
self.provision_handler.run()
# Enable RDMA, continue in errors
if conf.enable_rdma():
self.rdma_handler.install_driver()
logger.info("RDMA capabilities are enabled in configuration")
try:
# Ensure the most recent SharedConfig is available
# - Changes to RDMA state may not increment the goal state
# incarnation number. A forced update ensures the most
# current values.
protocol = self.protocol_util.get_protocol()
client = protocol.client
if client is None or type(client) is not WireClient:
raise Exception("Attempt to setup RDMA without Wireserver")
client.update_goal_state(forced=True)
setup_rdma_device()
except Exception as e:
logger.error("Error setting up rdma device: %s" % e)
else:
logger.info("RDMA capabilities are not enabled, skipping")
while self.running:
self.update_handler.run_latest(child_args=child_args)
def daemon(self, child_args=None):
logger.info("Run daemon")
self.protocol_util = get_protocol_util()
self.scvmm_handler = get_scvmm_handler()
self.resourcedisk_handler = get_resourcedisk_handler()
self.rdma_handler = get_rdma_handler()
self.provision_handler = get_provision_handler()
self.update_handler = get_update_handler()
# Create lib dir
if not os.path.isdir(conf.get_lib_dir()):
fileutil.mkdir(conf.get_lib_dir(), mode=0o700)
os.chdir(conf.get_lib_dir())
if conf.get_detect_scvmm_env():
self.scvmm_handler.run()
if conf.get_resourcedisk_format():
self.resourcedisk_handler.run()
# Always redetermine the protocol start (e.g., wireserver vs.
# on-premise) since a VHD can move between environments
self.protocol_util.clear_protocol()
self.provision_handler.run()
# Enable RDMA, continue in errors
if conf.enable_rdma():
self.rdma_handler.install_driver()
logger.info("RDMA capabilities are enabled in configuration")
try:
# Ensure the most recent SharedConfig is available
# - Changes to RDMA state may not increment the goal state
# incarnation number. A forced update ensures the most
# current values.
protocol = self.protocol_util.get_protocol()
client = protocol.client
if client is None or type(client) is not WireClient:
raise Exception("Attempt to setup RDMA without Wireserver")
client.update_goal_state(forced=True)
setup_rdma_device()
except Exception as e:
logger.error("Error setting up rdma device: %s" % e)
else:
logger.info("RDMA capabilities are not enabled, skipping")
while self.running:
self.update_handler.run_latest(child_args=child_args)
def test_change_partition_type(self):
resource_handler = get_resourcedisk_handler()
# test when sfdisk --part-type does not exist
with patch.object(shellutil, "run_get_output",
side_effect=[[1, ''], [0, '']]) as run_patch:
resource_handler.change_partition_type(suppress_message=True, option_str='')
# assert
assert run_patch.call_count == 2
assert "sfdisk --part-type" in run_patch.call_args_list[0][0][0]
assert "sfdisk -c" in run_patch.call_args_list[1][0][0]
# test when sfdisk --part-type exists
with patch.object(shellutil, "run_get_output",
side_effect=[[0, '']]) as run_patch:
resource_handler.change_partition_type(suppress_message=True, option_str='')
# assert
assert run_patch.call_count == 1
assert "sfdisk --part-type" in run_patch.call_args_list[0][0][0]
def test_change_partition_type(self):
resource_handler = get_resourcedisk_handler()
# test when sfdisk --part-type does not exist
with patch.object(shellutil, "run_get_output",
side_effect=[[1, ''], [0, '']]) as run_patch:
resource_handler.change_partition_type(suppress_message=True, option_str='')
# assert
assert run_patch.call_count == 2
assert "sfdisk --part-type" in run_patch.call_args_list[0][0][0]
assert "sfdisk -c" in run_patch.call_args_list[1][0][0]
# test when sfdisk --part-type exists
with patch.object(shellutil, "run_get_output",
side_effect=[[0, '']]) as run_patch:
resource_handler.change_partition_type(suppress_message=True, option_str='')
# assert
assert run_patch.call_count == 1
assert "sfdisk --part-type" in run_patch.call_args_list[0][0][0]
def daemon(self):
logger.info("Run daemon")
self.protocol_util = get_protocol_util()
self.scvmm_handler = get_scvmm_handler()
self.resourcedisk_handler = get_resourcedisk_handler()
self.rdma_handler = get_rdma_handler()
self.provision_handler = get_provision_handler()
self.update_handler = get_update_handler()
# Create lib dir
if not os.path.isdir(conf.get_lib_dir()):
fileutil.mkdir(conf.get_lib_dir(), mode=0o700)
os.chdir(conf.get_lib_dir())
if conf.get_detect_scvmm_env():
self.scvmm_handler.run()
if conf.get_resourcedisk_format():
self.resourcedisk_handler.run()
# Always redetermine the protocol start (e.g., wireserver vs.
# on-premise) since a VHD can move between environments
self.protocol_util.clear_protocol()
self.provision_handler.run()
# Enable RDMA, continue in errors
if conf.enable_rdma():
self.rdma_handler.install_driver()
logger.info("RDMA capabilities are enabled in configuration")
try:
setup_rdma_device()
except Exception as e:
logger.error("Error setting up rdma device: %s" % e)
else:
logger.info("RDMA capabilities are not enabled, skipping")
while self.running:
self.update_handler.run_latest()
def daemon(self):
logger.info("Run daemon")
self.protocol_util = get_protocol_util()
self.scvmm_handler = get_scvmm_handler()
self.resourcedisk_handler = get_resourcedisk_handler()
self.rdma_handler = get_rdma_handler()
self.provision_handler = get_provision_handler()
self.update_handler = get_update_handler()
# Create lib dir
if not os.path.isdir(conf.get_lib_dir()):
fileutil.mkdir(conf.get_lib_dir(), mode=0o700)
os.chdir(conf.get_lib_dir())
if conf.get_detect_scvmm_env():
self.scvmm_handler.run()
if conf.get_resourcedisk_format():
self.resourcedisk_handler.run()
# Always redetermine the protocol start (e.g., wireserver vs.
# on-premise) since a VHD can move between environments
self.protocol_util.clear_protocol()
self.provision_handler.run()
# Enable RDMA, continue in errors
if conf.enable_rdma():
self.rdma_handler.install_driver()
logger.info("RDMA capabilities are enabled in configuration")
try:
setup_rdma_device()
except Exception as e:
logger.error("Error setting up rdma device: %s" % e)
else:
logger.info("RDMA capabilities are not enabled, skipping")
while self.running:
self.update_handler.run_latest()
def test_mkfile_xfs_fs(self):
# setup
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
# execute
resource_disk_handler = get_resourcedisk_handler()
resource_disk_handler.fs = 'xfs'
with patch.object(shellutil, "run") as run_patch:
resource_disk_handler.mkfile(test_file, file_size)
# assert
if sys.version_info >= (3,3):
with patch("os.posix_fallocate") as posix_fallocate:
self.assertEqual(0, posix_fallocate.call_count)
assert run_patch.call_count == 1
assert "dd if" in run_patch.call_args_list[0][0][0]
def test_mkfile_xfs_fs(self):
# setup
test_file = os.path.join(self.tmp_dir, 'test_file')
file_size = 1024 * 128
if os.path.exists(test_file):
os.remove(test_file)
# execute
resource_disk_handler = get_resourcedisk_handler()
resource_disk_handler.fs = 'xfs'
with patch.object(shellutil, "run") as run_patch:
resource_disk_handler.mkfile(test_file, file_size)
# assert
if sys.version_info >= (3, 3):
with patch("os.posix_fallocate") as posix_fallocate:
self.assertEqual(0, posix_fallocate.call_count)
assert run_patch.call_count == 1
assert "dd if" in run_patch.call_args_list[0][0][0]