def bridge_pytest_and_runtests( reap_stray_processes, base_env_state_tree_root_dir, prod_env_state_tree_root_dir, base_env_pillar_tree_root_dir, prod_env_pillar_tree_root_dir, salt_factories, salt_mm_master, salt_mm_minion, salt_mm_sub_master, salt_mm_sub_minion, ): # Make sure unittest2 uses the pytest generated configuration RUNTIME_VARS.RUNTIME_CONFIGS["mm_master"] = freeze(salt_mm_master.config) RUNTIME_VARS.RUNTIME_CONFIGS["mm_minion"] = freeze(salt_mm_minion.config) RUNTIME_VARS.RUNTIME_CONFIGS["mm_sub_master"] = freeze(salt_mm_sub_master.config) RUNTIME_VARS.RUNTIME_CONFIGS["mm_sub_minion"] = freeze(salt_mm_sub_minion.config) # Make sure unittest2 classes know their paths RUNTIME_VARS.TMP_MM_CONF_DIR = os.path.dirname(salt_mm_master.config["conf_file"]) RUNTIME_VARS.TMP_MM_MINION_CONF_DIR = os.path.dirname( salt_mm_minion.config["conf_file"] ) RUNTIME_VARS.TMP_MM_SUB_CONF_DIR = os.path.dirname( salt_mm_sub_master.config["conf_file"] ) RUNTIME_VARS.TMP_MM_SUB_MINION_CONF_DIR = os.path.dirname( salt_mm_sub_minion.config["conf_file"] )
def mm_bridge_pytest_and_runtests( reap_stray_processes, session_mm_conf_dir, session_mm_secondary_conf_dir, session_base_env_pillar_tree_root_dir, session_base_env_state_tree_root_dir, session_prod_env_state_tree_root_dir, session_mm_master_config, session_mm_minion_config, session_mm_secondary_master_config, session_mm_secondary_minion_config, default_session_daemons): # Make sure unittest2 classes know their paths RUNTIME_VARS.TMP_MM_CONF_DIR = session_mm_conf_dir.realpath().strpath RUNTIME_VARS.TMP_MM_SUB_CONF_DIR = session_mm_secondary_conf_dir.realpath( ).strpath RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR = session_mm_secondary_conf_dir.realpath( ).strpath RUNTIME_VARS.TMP_PILLAR_TREE = session_base_env_pillar_tree_root_dir.realpath( ).strpath RUNTIME_VARS.TMP_STATE_TREE = session_base_env_state_tree_root_dir.realpath( ).strpath RUNTIME_VARS.TMP_PRODENV_STATE_TREE = session_prod_env_state_tree_root_dir.realpath( ).strpath # Make sure unittest2 uses the pytest generated configuration RUNTIME_VARS.RUNTIME_CONFIGS['mm_master'] = freeze( session_mm_master_config) RUNTIME_VARS.RUNTIME_CONFIGS['mm_minion'] = freeze( session_mm_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS['mm_sub_master'] = freeze( session_mm_secondary_master_config) RUNTIME_VARS.RUNTIME_CONFIGS['mm_sub_minion'] = freeze( session_mm_secondary_minion_config)
def get_config(config_for, from_scratch=False): if from_scratch: if config_for in ("master", "syndic_master", "mm_master", "mm_sub_master"): return salt.config.master_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for) ) elif config_for in ("minion", "sub_minion"): return salt.config.minion_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for), cache_minion_id=False, ) elif config_for in ("syndic",): return salt.config.syndic_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for), AdaptedConfigurationTestCaseMixin.get_config_file_path("minion"), ) elif config_for == "client_config": return salt.config.client_config( AdaptedConfigurationTestCaseMixin.get_config_file_path("master") ) if config_for not in RUNTIME_VARS.RUNTIME_CONFIGS: if config_for in ("master", "syndic_master", "mm_master", "mm_sub_master"): RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.master_config( AdaptedConfigurationTestCaseMixin.get_config_file_path( config_for ) ) ) elif config_for in ("minion", "sub_minion"): RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.minion_config( AdaptedConfigurationTestCaseMixin.get_config_file_path( config_for ) ) ) elif config_for in ("syndic",): RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.syndic_config( AdaptedConfigurationTestCaseMixin.get_config_file_path( config_for ), AdaptedConfigurationTestCaseMixin.get_config_file_path( "minion" ), ) ) elif config_for == "client_config": RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.client_config( AdaptedConfigurationTestCaseMixin.get_config_file_path("master") ) ) return RUNTIME_VARS.RUNTIME_CONFIGS[config_for]
def setUpClass(cls): cls._test_config = freeze( { "comment": "Configuration discarded.", "already_configured": False, "result": True, "diff": ( '[edit interfaces xe-0/0/5]+ description "Adding a description";' ), } ) cls._test_diff = freeze({"diff1": "value"})
def test_immutabledict_imutability(self): data = { 1: 1, 2: 2, 3: { 3.1: 3.1, 3.2: 3.2, 3.3: {3.31: 3.33, 3.32: 3.34, 3.33: [3.331, 3.332, 3.333]}, }, 4: [4.1, 4.2, 4.3], } frozen = immutabletypes.freeze(data) with self.assertRaises(TypeError): frozen[1] = 2 with self.assertRaises(TypeError): fdict = frozen[3] fdict[3.1] = 5 with self.assertRaises(TypeError): fdict = frozen[3] fdict[3.4] = 3.4 with self.assertRaises(TypeError): frozen[3][3.3][3.32] = 3.99 with self.assertRaises(TypeError): frozen[3][3.3][3.33][0] = 5 with self.assertRaises(TypeError): flist = frozen[4] flist[0] = 5
def lock(self): # Late import from salt.utils.immutabletypes import freeze frozen_vars = freeze(self._vars.copy()) self._vars = frozen_vars self._locked = True
def test_freeze_list_sum(self): lst = [4, 5, 6] imt = immutabletypes.freeze([1, 2, 3]) __add__ = imt + lst self.assertEqual(__add__, [1, 2, 3, 4, 5, 6]) __radd__ = lst + imt self.assertEqual(__radd__, [4, 5, 6, 1, 2, 3])
def test_immutablelist_imutability(self): frozen = immutabletypes.freeze([1, 2, 3]) with self.assertRaises(TypeError): frozen[1] = 2 with self.assertRaises(TypeError): frozen[1:-1] = 5
def get_config(config_for, from_scratch=False): if from_scratch: if config_for in ('master', 'syndic_master', 'mm_master', 'mm_sub_master'): return salt.config.master_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for) ) elif config_for in ('minion', 'sub_minion'): return salt.config.minion_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for) ) elif config_for in ('syndic',): return salt.config.syndic_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for), AdaptedConfigurationTestCaseMixin.get_config_file_path('minion') ) elif config_for == 'client_config': return salt.config.client_config( AdaptedConfigurationTestCaseMixin.get_config_file_path('master') ) if config_for not in RUNTIME_VARS.RUNTIME_CONFIGS: if config_for in ('master', 'syndic_master', 'mm_master', 'mm_sub_master'): RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.master_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for) ) ) elif config_for in ('minion', 'sub_minion'): RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.minion_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for) ) ) elif config_for in ('syndic',): RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.syndic_config( AdaptedConfigurationTestCaseMixin.get_config_file_path(config_for), AdaptedConfigurationTestCaseMixin.get_config_file_path('minion') ) ) elif config_for == 'client_config': RUNTIME_VARS.RUNTIME_CONFIGS[config_for] = freeze( salt.config.client_config( AdaptedConfigurationTestCaseMixin.get_config_file_path('master') ) ) return RUNTIME_VARS.RUNTIME_CONFIGS[config_for]
def __attrs_post_init__(self): if self.python_executable is None: self.python_executable = sys.executable # We really do not want buffered output self.environ.setdefault("PYTHONUNBUFFERED", "1") # Don't write .pyc files or create them in __pycache__ directories self.environ.setdefault("PYTHONDONTWRITEBYTECODE", "1") self.config_file = self.config["conf_file"] self.config_dir = os.path.dirname(self.config_file) self.id = self.config["id"] self.config = freeze(self.config)
def set_model(): return freeze({ "interfaces": { "interface": { "Ethernet1": { "config": { "name": "Ethernet1", "description": "Interface Ethernet1", }, "subinterfaces": { "subinterface": { "0": { "config": { "index": 0, "description": "Subinterface Ethernet1.0", } }, "100": { "config": { "index": 100, "description": "Subinterface Ethernet1.100", } }, "900": { "config": { "index": 900, "description": "Subinterface Ethernet1.900", } }, } }, }, "Ethernet2": { "config": { "name": "Ethernet2", "description": "Interface Ethernet2", }, "subinterfaces": { "subinterface": { "400": { "config": { "index": 400, "description": "Subinterface Ethernet2.400", } } } }, }, } } })
def bridge_pytest_and_runtests( reap_stray_processes, salt_factories, salt_syndic_master_factory, salt_syndic_factory, salt_master_factory, salt_minion_factory, salt_sub_minion_factory, sshd_config_dir, ): # Make sure unittest2 uses the pytest generated configuration RUNTIME_VARS.RUNTIME_CONFIGS["master"] = freeze(salt_master_factory.config) RUNTIME_VARS.RUNTIME_CONFIGS["minion"] = freeze(salt_minion_factory.config) RUNTIME_VARS.RUNTIME_CONFIGS["sub_minion"] = freeze( salt_sub_minion_factory.config) RUNTIME_VARS.RUNTIME_CONFIGS["syndic_master"] = freeze( salt_syndic_master_factory.config) RUNTIME_VARS.RUNTIME_CONFIGS["syndic"] = freeze(salt_syndic_factory.config) RUNTIME_VARS.RUNTIME_CONFIGS["client_config"] = freeze( salt.config.client_config(salt_master_factory.config["conf_file"])) # Make sure unittest2 classes know their paths RUNTIME_VARS.TMP_ROOT_DIR = str(salt_factories.root_dir.resolve()) RUNTIME_VARS.TMP_CONF_DIR = os.path.dirname( salt_master_factory.config["conf_file"]) RUNTIME_VARS.TMP_MINION_CONF_DIR = os.path.dirname( salt_minion_factory.config["conf_file"]) RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR = os.path.dirname( salt_sub_minion_factory.config["conf_file"]) RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR = os.path.dirname( salt_syndic_master_factory.config["conf_file"]) RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR = os.path.dirname( salt_syndic_factory.config["conf_file"]) RUNTIME_VARS.TMP_SSH_CONF_DIR = str(sshd_config_dir)
def bridge_pytest_and_runtests( reap_stray_processes, base_env_state_tree_root_dir, prod_env_state_tree_root_dir, base_env_pillar_tree_root_dir, prod_env_pillar_tree_root_dir, salt_factories, salt_syndic_master_config, salt_syndic_config, salt_master_config, salt_minion_config, salt_sub_minion_config, ): # Make sure unittest2 uses the pytest generated configuration RUNTIME_VARS.RUNTIME_CONFIGS["master"] = freeze(salt_master_config) RUNTIME_VARS.RUNTIME_CONFIGS["minion"] = freeze(salt_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS["sub_minion"] = freeze(salt_sub_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS["syndic_master"] = freeze( salt_syndic_master_config) RUNTIME_VARS.RUNTIME_CONFIGS["syndic"] = freeze(salt_syndic_config) RUNTIME_VARS.RUNTIME_CONFIGS["client_config"] = freeze( salt.config.client_config(salt_master_config["conf_file"])) # Make sure unittest2 classes know their paths RUNTIME_VARS.TMP_ROOT_DIR = salt_factories.root_dir.realpath().strpath RUNTIME_VARS.TMP_CONF_DIR = os.path.dirname( salt_master_config["conf_file"]) RUNTIME_VARS.TMP_MINION_CONF_DIR = os.path.dirname( salt_minion_config["conf_file"]) RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR = os.path.dirname( salt_sub_minion_config["conf_file"]) RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR = os.path.dirname( salt_syndic_master_config["conf_file"]) RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR = os.path.dirname( salt_syndic_config["conf_file"])
def bridge_pytest_and_runtests(session_root_dir, session_conf_dir, session_secondary_conf_dir, session_syndic_conf_dir, session_master_of_masters_conf_dir, session_state_tree_root_dir, session_pillar_tree_root_dir, session_prod_env_state_tree_root_dir, session_master_config, session_minion_config, session_secondary_minion_config, session_master_of_masters_config, session_syndic_config): # Make sure unittest2 classes know their paths RUNTIME_VARS.TMP = RUNTIME_VARS.SYS_TMP_DIR = session_root_dir.realpath().strpath RUNTIME_VARS.TMP_CONF_DIR = session_conf_dir.realpath().strpath RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR = session_secondary_conf_dir.realpath().strpath RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR = session_master_of_masters_conf_dir.realpath().strpath RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR = session_syndic_conf_dir.realpath().strpath RUNTIME_VARS.TMP_PILLAR_TREE = session_pillar_tree_root_dir.realpath().strpath RUNTIME_VARS.TMP_STATE_TREE = session_state_tree_root_dir.realpath().strpath RUNTIME_VARS.TMP_PRODENV_STATE_TREE = session_prod_env_state_tree_root_dir.realpath().strpath # Make sure unittest2 uses the pytest generated configuration RUNTIME_VARS.RUNTIME_CONFIGS['master'] = freeze(session_master_config) RUNTIME_VARS.RUNTIME_CONFIGS['minion'] = freeze(session_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS['sub_minion'] = freeze(session_secondary_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS['syndic_master'] = freeze(session_master_of_masters_config) RUNTIME_VARS.RUNTIME_CONFIGS['syndic'] = freeze(session_syndic_config) RUNTIME_VARS.RUNTIME_CONFIGS['client_config'] = freeze(session_master_config)
def bridge_pytest_and_runtests( reap_stray_processes, session_root_dir, session_conf_dir, session_secondary_conf_dir, session_syndic_conf_dir, session_master_of_masters_conf_dir, session_base_env_pillar_tree_root_dir, session_base_env_state_tree_root_dir, session_prod_env_state_tree_root_dir, session_master_config, session_minion_config, session_secondary_minion_config, session_master_of_masters_config, session_syndic_config): # Make sure unittest2 classes know their paths RUNTIME_VARS.TMP_ROOT_DIR = session_root_dir.realpath().strpath RUNTIME_VARS.TMP_CONF_DIR = session_conf_dir.realpath().strpath RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR = session_secondary_conf_dir.realpath( ).strpath RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR = session_master_of_masters_conf_dir.realpath( ).strpath RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR = session_syndic_conf_dir.realpath( ).strpath RUNTIME_VARS.TMP_PILLAR_TREE = session_base_env_pillar_tree_root_dir.realpath( ).strpath RUNTIME_VARS.TMP_STATE_TREE = session_base_env_state_tree_root_dir.realpath( ).strpath RUNTIME_VARS.TMP_PRODENV_STATE_TREE = session_prod_env_state_tree_root_dir.realpath( ).strpath # Make sure unittest2 uses the pytest generated configuration RUNTIME_VARS.RUNTIME_CONFIGS['master'] = freeze(session_master_config) RUNTIME_VARS.RUNTIME_CONFIGS['minion'] = freeze(session_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS['sub_minion'] = freeze( session_secondary_minion_config) RUNTIME_VARS.RUNTIME_CONFIGS['syndic_master'] = freeze( session_master_of_masters_config) RUNTIME_VARS.RUNTIME_CONFIGS['syndic'] = freeze(session_syndic_config) RUNTIME_VARS.RUNTIME_CONFIGS['client_config'] = freeze( salt.config.client_config(session_conf_dir.join('master').strpath)) # Copy configuration files and directories which are not automatically generated for entry in os.listdir(RUNTIME_VARS.CONF_DIR): if entry in ('master', 'minion', 'sub_minion', 'syndic', 'syndic_master', 'proxy'): # These have runtime computed values and are handled by pytest-salt fixtures continue entry_path = os.path.join(RUNTIME_VARS.CONF_DIR, entry) if os.path.isfile(entry_path): shutil.copy(entry_path, os.path.join(RUNTIME_VARS.TMP_CONF_DIR, entry)) elif os.path.isdir(entry_path): shutil.copytree(entry_path, os.path.join(RUNTIME_VARS.TMP_CONF_DIR, entry))
def set_defaults(): return freeze({ "interfaces": { "interface": { "*": { "config": { "mtu": 2048, "enabled": True }, "subinterfaces": { "subinterface": { "*": { "config": { "enabled": True } } } }, } } } })
def test_immutabledict_imutability(self): data = { 1: 1, 2: 2, 3: { 3.1: 3.1, 3.2: 3.2, 3.3: { 3.31: 3.33, 3.32: 3.34, 3.33: [3.331, 3.332, 3.333] } }, 4: [4.1, 4.2, 4.3] } frozen = immutabletypes.freeze(data) with self.assertRaises(TypeError): frozen[1] = 2 with self.assertRaises(TypeError): fdict = frozen[3] fdict[3.1] = 5 with self.assertRaises(TypeError): fdict = frozen[3] fdict[3.4] = 3.4 with self.assertRaises(TypeError): frozen[3][3.3][3.32] = 3.99 with self.assertRaises(TypeError): frozen[3][3.3][3.33][0] = 5 with self.assertRaises(TypeError): flist = frozen[4] flist[0] = 5
def transplant_configs(cls, transport="zeromq"): os.makedirs(RUNTIME_VARS.TMP_MM_CONF_DIR) os.makedirs(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR) print( " * Transplanting multimaster configuration files to '{0}'".format( RUNTIME_VARS.TMP_CONF_DIR)) tests_known_hosts_file = os.path.join(RUNTIME_VARS.TMP_CONF_DIR, "salt_ssh_known_hosts") # Primary master in multimaster environment master_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "master")) master_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "mm_master"))) master_opts["known_hosts_file"] = tests_known_hosts_file master_opts["cachedir"] = "cache" master_opts["user"] = RUNTIME_VARS.RUNNING_TESTS_USER master_opts["config_dir"] = RUNTIME_VARS.TMP_MM_CONF_DIR master_opts["root_dir"] = os.path.join(TMP, "rootdir-multimaster") master_opts["pki_dir"] = "pki" file_tree = { "root_dir": os.path.join(FILES, "pillar", "base", "file_tree"), "follow_dir_links": False, "keep_newline": True, } master_opts["ext_pillar"].append({"file_tree": file_tree}) # Secondary master in multimaster environment sub_master_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "master")) sub_master_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "mm_sub_master"))) sub_master_opts["known_hosts_file"] = tests_known_hosts_file sub_master_opts["cachedir"] = "cache" sub_master_opts["user"] = RUNTIME_VARS.RUNNING_TESTS_USER sub_master_opts["config_dir"] = RUNTIME_VARS.TMP_MM_SUB_CONF_DIR sub_master_opts["root_dir"] = os.path.join(TMP, "rootdir-sub-multimaster") sub_master_opts["pki_dir"] = "pki" sub_master_opts["ext_pillar"].append( {"file_tree": copy.deepcopy(file_tree)}) # Under windows we can't seem to properly create a virtualenv off of another # virtualenv, we can on linux but we will still point to the virtualenv binary # outside the virtualenv running the test suite, if that's the case. try: real_prefix = sys.real_prefix # The above attribute exists, this is a virtualenv if salt.utils.platform.is_windows(): virtualenv_binary = os.path.join(real_prefix, "Scripts", "virtualenv.exe") else: # We need to remove the virtualenv from PATH or we'll get the virtualenv binary # from within the virtualenv, we don't want that path = os.environ.get("PATH") if path is not None: path_items = path.split(os.pathsep) for item in path_items[:]: if item.startswith(sys.base_prefix): path_items.remove(item) os.environ["PATH"] = os.pathsep.join(path_items) virtualenv_binary = salt.utils.path.which("virtualenv") if path is not None: # Restore previous environ PATH os.environ["PATH"] = path if not virtualenv_binary.startswith(real_prefix): virtualenv_binary = None if virtualenv_binary and not os.path.exists(virtualenv_binary): # It doesn't exist?! virtualenv_binary = None except AttributeError: # We're not running inside a virtualenv virtualenv_binary = None # This minion connects to both masters minion_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "minion")) minion_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "mm_minion"))) minion_opts["cachedir"] = "cache" minion_opts["user"] = RUNTIME_VARS.RUNNING_TESTS_USER minion_opts["config_dir"] = RUNTIME_VARS.TMP_MM_CONF_DIR minion_opts["root_dir"] = os.path.join(TMP, "rootdir-multimaster") minion_opts["pki_dir"] = "pki" minion_opts["hosts.file"] = os.path.join(TMP, "rootdir", "hosts") minion_opts["aliases.file"] = os.path.join(TMP, "rootdir", "aliases") if virtualenv_binary: minion_opts["venv_bin"] = virtualenv_binary # This sub_minion also connects to both masters sub_minion_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "sub_minion")) sub_minion_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, "mm_sub_minion"))) sub_minion_opts["cachedir"] = "cache" sub_minion_opts["user"] = RUNTIME_VARS.RUNNING_TESTS_USER sub_minion_opts["config_dir"] = RUNTIME_VARS.TMP_MM_SUB_CONF_DIR sub_minion_opts["root_dir"] = os.path.join(TMP, "rootdir-sub-multimaster") sub_minion_opts["pki_dir"] = "pki" sub_minion_opts["hosts.file"] = os.path.join(TMP, "rootdir", "hosts") sub_minion_opts["aliases.file"] = os.path.join(TMP, "rootdir", "aliases") if virtualenv_binary: sub_minion_opts["venv_bin"] = virtualenv_binary if transport == "raet": master_opts["transport"] = "raet" master_opts["raet_port"] = 64506 sub_master_opts["transport"] = "raet" sub_master_opts["raet_port"] = 64556 minion_opts["transport"] = "raet" minion_opts["raet_port"] = 64510 sub_minion_opts["transport"] = "raet" sub_minion_opts["raet_port"] = 64520 # syndic_master_opts['transport'] = 'raet' if transport == "tcp": master_opts["transport"] = "tcp" sub_master_opts["transport"] = "tcp" minion_opts["transport"] = "tcp" sub_minion_opts["transport"] = "tcp" # Set up config options that require internal data master_opts["pillar_roots"] = sub_master_opts["pillar_roots"] = { "base": [ RUNTIME_VARS.TMP_PILLAR_TREE, os.path.join(FILES, "pillar", "base"), ] } minion_opts["pillar_roots"] = { "base": [ RUNTIME_VARS.TMP_PILLAR_TREE, os.path.join(FILES, "pillar", "base"), ] } master_opts["file_roots"] = sub_master_opts["file_roots"] = { "base": [ os.path.join(FILES, "file", "base"), # Let's support runtime created files that can be used like: # salt://my-temp-file.txt RUNTIME_VARS.TMP_STATE_TREE, ], # Alternate root to test __env__ choices "prod": [ os.path.join(FILES, "file", "prod"), RUNTIME_VARS.TMP_PRODENV_STATE_TREE, ], } minion_opts["file_roots"] = { "base": [ os.path.join(FILES, "file", "base"), # Let's support runtime created files that can be used like: # salt://my-temp-file.txt RUNTIME_VARS.TMP_STATE_TREE, ], # Alternate root to test __env__ choices "prod": [ os.path.join(FILES, "file", "prod"), RUNTIME_VARS.TMP_PRODENV_STATE_TREE, ], } master_opts.setdefault("reactor", []).append({ "salt/minion/*/start": [os.path.join(FILES, "reactor-sync-minion.sls")] }) for opts_dict in (master_opts, sub_master_opts): if "ext_pillar" not in opts_dict: opts_dict["ext_pillar"] = [] if salt.utils.platform.is_windows(): opts_dict["ext_pillar"].append({ "cmd_yaml": "type {0}".format(os.path.join(FILES, "ext.yaml")) }) else: opts_dict["ext_pillar"].append({ "cmd_yaml": "cat {0}".format(os.path.join(FILES, "ext.yaml")) }) # all read, only owner write autosign_file_permissions = (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR) for opts_dict in (master_opts, sub_master_opts): # We need to copy the extension modules into the new master root_dir or # it will be prefixed by it new_extension_modules_path = os.path.join(opts_dict["root_dir"], "extension_modules") if not os.path.exists(new_extension_modules_path): shutil.copytree( os.path.join(INTEGRATION_TEST_DIR, "files", "extension_modules"), new_extension_modules_path, ) opts_dict["extension_modules"] = os.path.join( opts_dict["root_dir"], "extension_modules") # Copy the autosign_file to the new master root_dir new_autosign_file_path = os.path.join(opts_dict["root_dir"], "autosign_file") shutil.copyfile( os.path.join(INTEGRATION_TEST_DIR, "files", "autosign_file"), new_autosign_file_path, ) os.chmod(new_autosign_file_path, autosign_file_permissions) # Point the config values to the correct temporary paths for name in ("hosts", "aliases"): optname = "{0}.file".format(name) optname_path = os.path.join(TMP, name) master_opts[optname] = optname_path sub_master_opts[optname] = optname_path minion_opts[optname] = optname_path sub_minion_opts[optname] = optname_path master_opts["runtests_conn_check_port"] = get_unused_localhost_port() sub_master_opts[ "runtests_conn_check_port"] = get_unused_localhost_port() minion_opts["runtests_conn_check_port"] = get_unused_localhost_port() sub_minion_opts[ "runtests_conn_check_port"] = get_unused_localhost_port() for conf in (master_opts, sub_master_opts, minion_opts, sub_minion_opts): if "engines" not in conf: conf["engines"] = [] conf["engines"].append({"salt_runtests": {}}) if "engines_dirs" not in conf: conf["engines_dirs"] = [] conf["engines_dirs"].insert(0, ENGINES_DIR) if "log_handlers_dirs" not in conf: conf["log_handlers_dirs"] = [] conf["log_handlers_dirs"].insert(0, LOG_HANDLERS_DIR) conf["runtests_log_port"] = SALT_LOG_PORT conf["runtests_log_level"] = ( os.environ.get("TESTS_MIN_LOG_LEVEL_NAME") or "debug") # ----- Transcribe Configuration ----------------------------------------------------------------------------> computed_config = copy.deepcopy(master_opts) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, "master"), "w") as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(master_opts), wfh, default_flow_style=False) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, "master"), "w") as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(sub_master_opts), wfh, default_flow_style=False) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, "minion"), "w") as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(minion_opts), wfh, default_flow_style=False) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, "minion"), "w") as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(sub_minion_opts), wfh, default_flow_style=False) # <---- Transcribe Configuration ----------------------------------------------------------------------------- # ----- Verify Environment ----------------------------------------------------------------------------------> master_opts = salt.config.master_config( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, "master")) sub_master_opts = salt.config.master_config( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, "master")) minion_opts = salt.config.minion_config( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, "minion")) sub_minion_opts = salt.config.minion_config( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, "minion")) RUNTIME_VARS.RUNTIME_CONFIGS["mm_master"] = freeze(master_opts) RUNTIME_VARS.RUNTIME_CONFIGS["mm_sub_master"] = freeze(sub_master_opts) RUNTIME_VARS.RUNTIME_CONFIGS["mm_minion"] = freeze(minion_opts) RUNTIME_VARS.RUNTIME_CONFIGS["mm_sub_minion"] = freeze(sub_minion_opts) verify_env( [ os.path.join(master_opts["pki_dir"], "minions"), os.path.join(master_opts["pki_dir"], "minions_pre"), os.path.join(master_opts["pki_dir"], "minions_rejected"), os.path.join(master_opts["pki_dir"], "minions_denied"), os.path.join(master_opts["cachedir"], "jobs"), os.path.join(master_opts["cachedir"], "raet"), os.path.join(master_opts["root_dir"], "cache", "tokens"), os.path.join(master_opts["pki_dir"], "accepted"), os.path.join(master_opts["pki_dir"], "rejected"), os.path.join(master_opts["pki_dir"], "pending"), os.path.join(master_opts["cachedir"], "raet"), os.path.join(sub_master_opts["pki_dir"], "minions"), os.path.join(sub_master_opts["pki_dir"], "minions_pre"), os.path.join(sub_master_opts["pki_dir"], "minions_rejected"), os.path.join(sub_master_opts["pki_dir"], "minions_denied"), os.path.join(sub_master_opts["cachedir"], "jobs"), os.path.join(sub_master_opts["cachedir"], "raet"), os.path.join(sub_master_opts["root_dir"], "cache", "tokens"), os.path.join(sub_master_opts["pki_dir"], "accepted"), os.path.join(sub_master_opts["pki_dir"], "rejected"), os.path.join(sub_master_opts["pki_dir"], "pending"), os.path.join(sub_master_opts["cachedir"], "raet"), os.path.join(minion_opts["pki_dir"], "accepted"), os.path.join(minion_opts["pki_dir"], "rejected"), os.path.join(minion_opts["pki_dir"], "pending"), os.path.join(minion_opts["cachedir"], "raet"), os.path.join(sub_minion_opts["pki_dir"], "accepted"), os.path.join(sub_minion_opts["pki_dir"], "rejected"), os.path.join(sub_minion_opts["pki_dir"], "pending"), os.path.join(sub_minion_opts["cachedir"], "raet"), os.path.dirname(master_opts["log_file"]), minion_opts["extension_modules"], sub_minion_opts["extension_modules"], sub_minion_opts["pki_dir"], master_opts["sock_dir"], sub_master_opts["sock_dir"], sub_minion_opts["sock_dir"], minion_opts["sock_dir"], ], RUNTIME_VARS.RUNNING_TESTS_USER, root_dir=master_opts["root_dir"], ) cls.mm_master_opts = master_opts cls.mm_sub_master_opts = sub_master_opts cls.mm_minion_opts = minion_opts cls.mm_sub_minion_opts = sub_minion_opts
_OPTS = freeze({ "__role": "minion", "environment": None, "pillarenv": None, "hash_type": "sha256", "file_roots": {}, "state_top": "top.sls", "state_top_saltenv": None, "renderer": "yaml_jinja", "renderer_whitelist": [], "renderer_blacklist": [], "pillar_merge_lists": False, "git_pillar_base": "master", "git_pillar_branch": "master", "git_pillar_env": "", "git_pillar_fallback": "", "git_pillar_root": "", "git_pillar_ssl_verify": True, "git_pillar_global_lock": True, "git_pillar_user": "", "git_pillar_password": "", "git_pillar_insecure_auth": False, "git_pillar_privkey": "", "git_pillar_pubkey": "", "git_pillar_passphrase": "", "git_pillar_refspecs": [ "+refs/heads/*:refs/remotes/origin/*", "+refs/tags/*:refs/tags/*", ], "git_pillar_includes": True, })
def transplant_configs(cls, transport='zeromq'): os.makedirs(RUNTIME_VARS.TMP_MM_CONF_DIR) os.makedirs(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR) print(' * Transplanting multimaster configuration files to \'{0}\''. format(RUNTIME_VARS.TMP_CONF_DIR)) tests_known_hosts_file = os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'salt_ssh_known_hosts') # Primary master in multimaster environment master_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'master')) master_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'mm_master'))) master_opts['known_hosts_file'] = tests_known_hosts_file master_opts['cachedir'] = os.path.join(TMP, 'rootdir_multimaster', 'cache') master_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER master_opts['config_dir'] = RUNTIME_VARS.TMP_MM_CONF_DIR master_opts['root_dir'] = os.path.join(TMP, 'rootdir-multimaster') master_opts['pki_dir'] = os.path.join(TMP, 'rootdir-multimaster', 'pki', 'master') file_tree = { 'root_dir': os.path.join(FILES, 'pillar', 'base', 'file_tree'), 'follow_dir_links': False, 'keep_newline': True, } master_opts['ext_pillar'].append({'file_tree': file_tree}) # Secondary master in multimaster environment sub_master_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'master')) sub_master_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'mm_sub_master'))) sub_master_opts['known_hosts_file'] = tests_known_hosts_file sub_master_opts['cachedir'] = os.path.join(TMP, 'rootdir-sub-multimaster', 'cache') sub_master_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER sub_master_opts['config_dir'] = RUNTIME_VARS.TMP_MM_SUB_CONF_DIR sub_master_opts['root_dir'] = os.path.join(TMP, 'rootdir-sub-multimaster') sub_master_opts['pki_dir'] = os.path.join(TMP, 'rootdir-sub-multimaster', 'pki', 'master') sub_master_opts['ext_pillar'].append( {'file_tree': copy.deepcopy(file_tree)}) # Under windows we can't seem to properly create a virtualenv off of another # virtualenv, we can on linux but we will still point to the virtualenv binary # outside the virtualenv running the test suite, if that's the case. try: real_prefix = sys.real_prefix # The above attribute exists, this is a virtualenv if salt.utils.is_windows(): virtualenv_binary = os.path.join(real_prefix, 'Scripts', 'virtualenv.exe') else: # We need to remove the virtualenv from PATH or we'll get the virtualenv binary # from within the virtualenv, we don't want that path = os.environ.get('PATH') if path is not None: path_items = path.split(os.pathsep) for item in path_items[:]: if item.startswith(sys.base_prefix): path_items.remove(item) os.environ['PATH'] = os.pathsep.join(path_items) virtualenv_binary = salt.utils.which('virtualenv') if path is not None: # Restore previous environ PATH os.environ['PATH'] = path if not virtualenv_binary.startswith(real_prefix): virtualenv_binary = None if virtualenv_binary and not os.path.exists(virtualenv_binary): # It doesn't exist?! virtualenv_binary = None except AttributeError: # We're not running inside a virtualenv virtualenv_binary = None # This minion connects to both masters minion_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'minion')) minion_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'mm_minion'))) minion_opts['cachedir'] = os.path.join(TMP, 'rootdir-multimaster', 'cache') minion_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER minion_opts['config_dir'] = RUNTIME_VARS.TMP_MM_CONF_DIR minion_opts['root_dir'] = os.path.join(TMP, 'rootdir-multimaster') minion_opts['pki_dir'] = os.path.join(TMP, 'rootdir-multimaster', 'pki', 'minion') minion_opts['hosts.file'] = os.path.join(TMP, 'rootdir', 'hosts') minion_opts['aliases.file'] = os.path.join(TMP, 'rootdir', 'aliases') if virtualenv_binary: minion_opts['venv_bin'] = virtualenv_binary # This sub_minion also connects to both masters sub_minion_opts = salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'sub_minion')) sub_minion_opts.update( salt.config._read_conf_file( os.path.join(RUNTIME_VARS.CONF_DIR, 'mm_sub_minion'))) sub_minion_opts['cachedir'] = os.path.join(TMP, 'rootdir-sub-multimaster', 'cache') sub_minion_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER sub_minion_opts['config_dir'] = RUNTIME_VARS.TMP_MM_SUB_CONF_DIR sub_minion_opts['root_dir'] = os.path.join(TMP, 'rootdir-sub-multimaster') sub_minion_opts['pki_dir'] = os.path.join(TMP, 'rootdir-sub-multimaster', 'pki', 'minion') sub_minion_opts['hosts.file'] = os.path.join(TMP, 'rootdir', 'hosts') sub_minion_opts['aliases.file'] = os.path.join(TMP, 'rootdir', 'aliases') if virtualenv_binary: sub_minion_opts['venv_bin'] = virtualenv_binary if transport == 'raet': master_opts['transport'] = 'raet' master_opts['raet_port'] = 64506 sub_master_opts['transport'] = 'raet' sub_master_opts['raet_port'] = 64556 minion_opts['transport'] = 'raet' minion_opts['raet_port'] = 64510 sub_minion_opts['transport'] = 'raet' sub_minion_opts['raet_port'] = 64520 # syndic_master_opts['transport'] = 'raet' if transport == 'tcp': master_opts['transport'] = 'tcp' sub_master_opts['transport'] = 'tcp' minion_opts['transport'] = 'tcp' sub_minion_opts['transport'] = 'tcp' # Set up config options that require internal data master_opts['pillar_roots'] = sub_master_opts['pillar_roots'] = { 'base': [ RUNTIME_VARS.TMP_PILLAR_TREE, os.path.join(FILES, 'pillar', 'base'), ] } minion_opts['pillar_roots'] = { 'base': [ RUNTIME_VARS.TMP_PILLAR_TREE, os.path.join(FILES, 'pillar', 'base'), ] } master_opts['file_roots'] = sub_master_opts['file_roots'] = { 'base': [ os.path.join(FILES, 'file', 'base'), # Let's support runtime created files that can be used like: # salt://my-temp-file.txt RUNTIME_VARS.TMP_STATE_TREE ], # Alternate root to test __env__ choices 'prod': [ os.path.join(FILES, 'file', 'prod'), RUNTIME_VARS.TMP_PRODENV_STATE_TREE ] } minion_opts['file_roots'] = { 'base': [ os.path.join(FILES, 'file', 'base'), # Let's support runtime created files that can be used like: # salt://my-temp-file.txt RUNTIME_VARS.TMP_STATE_TREE ], # Alternate root to test __env__ choices 'prod': [ os.path.join(FILES, 'file', 'prod'), RUNTIME_VARS.TMP_PRODENV_STATE_TREE ] } master_opts.setdefault('reactor', []).append({ 'salt/minion/*/start': [os.path.join(FILES, 'reactor-sync-minion.sls')], }) for opts_dict in (master_opts, sub_master_opts): if 'ext_pillar' not in opts_dict: opts_dict['ext_pillar'] = [] if salt.utils.platform.is_windows(): opts_dict['ext_pillar'].append({ 'cmd_yaml': 'type {0}'.format(os.path.join(FILES, 'ext.yaml')) }) else: opts_dict['ext_pillar'].append({ 'cmd_yaml': 'cat {0}'.format(os.path.join(FILES, 'ext.yaml')) }) # all read, only owner write autosign_file_permissions = stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR for opts_dict in (master_opts, sub_master_opts): # We need to copy the extension modules into the new master root_dir or # it will be prefixed by it new_extension_modules_path = os.path.join(opts_dict['root_dir'], 'extension_modules') if not os.path.exists(new_extension_modules_path): shutil.copytree( os.path.join(INTEGRATION_TEST_DIR, 'files', 'extension_modules'), new_extension_modules_path) opts_dict['extension_modules'] = os.path.join( opts_dict['root_dir'], 'extension_modules') # Copy the autosign_file to the new master root_dir new_autosign_file_path = os.path.join(opts_dict['root_dir'], 'autosign_file') shutil.copyfile( os.path.join(INTEGRATION_TEST_DIR, 'files', 'autosign_file'), new_autosign_file_path) os.chmod(new_autosign_file_path, autosign_file_permissions) # Point the config values to the correct temporary paths for name in ('hosts', 'aliases'): optname = '{0}.file'.format(name) optname_path = os.path.join(TMP, name) master_opts[optname] = optname_path sub_master_opts[optname] = optname_path minion_opts[optname] = optname_path sub_minion_opts[optname] = optname_path master_opts['runtests_conn_check_port'] = get_unused_localhost_port() sub_master_opts[ 'runtests_conn_check_port'] = get_unused_localhost_port() minion_opts['runtests_conn_check_port'] = get_unused_localhost_port() sub_minion_opts[ 'runtests_conn_check_port'] = get_unused_localhost_port() for conf in (master_opts, sub_master_opts, minion_opts, sub_minion_opts): if 'engines' not in conf: conf['engines'] = [] conf['engines'].append({'salt_runtests': {}}) if 'engines_dirs' not in conf: conf['engines_dirs'] = [] conf['engines_dirs'].insert(0, ENGINES_DIR) if 'log_handlers_dirs' not in conf: conf['log_handlers_dirs'] = [] conf['log_handlers_dirs'].insert(0, LOG_HANDLERS_DIR) conf['runtests_log_port'] = SALT_LOG_PORT conf['runtests_log_level'] = os.environ.get( 'TESTS_MIN_LOG_LEVEL_NAME') or 'debug' # ----- Transcribe Configuration ----------------------------------------------------------------------------> computed_config = copy.deepcopy(master_opts) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, 'master'), 'w') as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(master_opts), wfh, default_flow_style=False) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, 'master'), 'w') as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(sub_master_opts), wfh, default_flow_style=False) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, 'minion'), 'w') as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(minion_opts), wfh, default_flow_style=False) with salt.utils.files.fopen( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, 'minion'), 'w') as wfh: salt.utils.yaml.safe_dump(copy.deepcopy(sub_minion_opts), wfh, default_flow_style=False) # <---- Transcribe Configuration ----------------------------------------------------------------------------- # ----- Verify Environment ----------------------------------------------------------------------------------> master_opts = salt.config.master_config( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, 'master')) sub_master_opts = salt.config.master_config( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, 'master')) minion_opts = salt.config.minion_config( os.path.join(RUNTIME_VARS.TMP_MM_CONF_DIR, 'minion')) sub_minion_opts = salt.config.minion_config( os.path.join(RUNTIME_VARS.TMP_MM_SUB_CONF_DIR, 'minion')) RUNTIME_VARS.RUNTIME_CONFIGS['mm_master'] = freeze(master_opts) RUNTIME_VARS.RUNTIME_CONFIGS['mm_sub_master'] = freeze(sub_master_opts) RUNTIME_VARS.RUNTIME_CONFIGS['mm_minion'] = freeze(minion_opts) RUNTIME_VARS.RUNTIME_CONFIGS['mm_sub_minion'] = freeze(sub_minion_opts) verify_env( [ os.path.join(master_opts['pki_dir'], 'minions'), os.path.join(master_opts['pki_dir'], 'minions_pre'), os.path.join(master_opts['pki_dir'], 'minions_rejected'), os.path.join(master_opts['pki_dir'], 'minions_denied'), os.path.join(master_opts['cachedir'], 'jobs'), os.path.join(master_opts['cachedir'], 'raet'), os.path.join(master_opts['root_dir'], 'cache', 'tokens'), os.path.join(master_opts['pki_dir'], 'accepted'), os.path.join(master_opts['pki_dir'], 'rejected'), os.path.join(master_opts['pki_dir'], 'pending'), os.path.join(master_opts['cachedir'], 'raet'), os.path.join(sub_master_opts['pki_dir'], 'minions'), os.path.join(sub_master_opts['pki_dir'], 'minions_pre'), os.path.join(sub_master_opts['pki_dir'], 'minions_rejected'), os.path.join(sub_master_opts['pki_dir'], 'minions_denied'), os.path.join(sub_master_opts['cachedir'], 'jobs'), os.path.join(sub_master_opts['cachedir'], 'raet'), os.path.join(sub_master_opts['root_dir'], 'cache', 'tokens'), os.path.join(sub_master_opts['pki_dir'], 'accepted'), os.path.join(sub_master_opts['pki_dir'], 'rejected'), os.path.join(sub_master_opts['pki_dir'], 'pending'), os.path.join(sub_master_opts['cachedir'], 'raet'), os.path.join(minion_opts['pki_dir'], 'accepted'), os.path.join(minion_opts['pki_dir'], 'rejected'), os.path.join(minion_opts['pki_dir'], 'pending'), os.path.join(minion_opts['cachedir'], 'raet'), os.path.join(sub_minion_opts['pki_dir'], 'accepted'), os.path.join(sub_minion_opts['pki_dir'], 'rejected'), os.path.join(sub_minion_opts['pki_dir'], 'pending'), os.path.join(sub_minion_opts['cachedir'], 'raet'), os.path.dirname(master_opts['log_file']), minion_opts['extension_modules'], sub_minion_opts['extension_modules'], sub_minion_opts['pki_dir'], master_opts['sock_dir'], sub_master_opts['sock_dir'], sub_minion_opts['sock_dir'], minion_opts['sock_dir'], ], RUNTIME_VARS.RUNNING_TESTS_USER, root_dir=master_opts['root_dir'], ) cls.mm_master_opts = master_opts cls.mm_sub_master_opts = sub_master_opts cls.mm_minion_opts = minion_opts cls.mm_sub_minion_opts = sub_minion_opts
def freeze_logging_options_dict(): """ Turn the logging options dictionary into an immutable dictionary """ set_logging_options_dict.__options_dict__ = freeze( set_logging_options_dict.__options_dict__)
""" Base classes for napalm unit tests :codeauthor: :email:`Anthony Shaw <*****@*****.**>` """ from functools import wraps from salt.utils.immutabletypes import freeze TEST_INTERFACES = freeze({ "Management1": { "is_up": False, "is_enabled": False, "description": "", "last_flapped": -1, "speed": 1000, "mac_address": "dead:beef:dead", } }) # Test data TEST_FACTS = freeze({ "__opts__": {}, "OPTIONAL_ARGS": {}, "uptime": "Forever", "UP": True, "HOSTNAME": "test-device.com", "hostname": "test-device.com", "username": "******", "os_version": "1.2.3",
def transplant_configs(cls, transport='zeromq'): if os.path.isdir(RUNTIME_VARS.TMP): shutil.rmtree(RUNTIME_VARS.TMP) os.makedirs(RUNTIME_VARS.TMP) os.makedirs(RUNTIME_VARS.TMP_ROOT_DIR) os.makedirs(RUNTIME_VARS.TMP_CONF_DIR) os.makedirs(RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR) os.makedirs(RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR) os.makedirs(RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR) print(' * Transplanting configuration files to \'{0}\''.format(RUNTIME_VARS.TMP_CONF_DIR)) tests_known_hosts_file = os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'salt_ssh_known_hosts') with salt.utils.files.fopen(tests_known_hosts_file, 'w') as known_hosts: known_hosts.write('') # This master connects to syndic_master via a syndic master_opts = salt.config._read_conf_file(os.path.join(RUNTIME_VARS.CONF_DIR, 'master')) master_opts['known_hosts_file'] = tests_known_hosts_file master_opts['cachedir'] = 'cache' master_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER master_opts['root_dir'] = os.path.join(TMP_ROOT_DIR) master_opts['pki_dir'] = 'pki' master_opts['syndic_master'] = 'localhost' pytest_stop_sending_events_file = os.path.join(TMP_ROOT_DIR, 'pytest_stop_sending_events_file_master') with salt.utils.files.fopen(pytest_stop_sending_events_file, 'w') as wfh: wfh.write('') master_opts['pytest_stop_sending_events_file'] = pytest_stop_sending_events_file # This minion connects to master minion_opts = salt.config._read_conf_file(os.path.join(RUNTIME_VARS.CONF_DIR, 'minion')) minion_opts['cachedir'] = 'cache' minion_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER minion_opts['root_dir'] = os.path.join(TMP_ROOT_DIR) minion_opts['pki_dir'] = 'pki' minion_opts['hosts.file'] = os.path.join(TMP_ROOT_DIR, 'hosts') minion_opts['aliases.file'] = os.path.join(TMP_ROOT_DIR, 'aliases') # This sub_minion also connects to master sub_minion_opts = salt.config._read_conf_file(os.path.join(RUNTIME_VARS.CONF_DIR, 'sub_minion')) sub_minion_opts['cachedir'] = 'cache' sub_minion_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER sub_minion_opts['root_dir'] = os.path.join(TMP, 'rootdir-sub-minion') sub_minion_opts['pki_dir'] = 'pki' sub_minion_opts['hosts.file'] = os.path.join(TMP_ROOT_DIR, 'hosts') sub_minion_opts['aliases.file'] = os.path.join(TMP_ROOT_DIR, 'aliases') # This is the master of masters syndic_master_opts = salt.config._read_conf_file(os.path.join(RUNTIME_VARS.CONF_DIR, 'syndic_master')) syndic_master_opts['cachedir'] = 'cache' syndic_master_opts['user'] = RUNTIME_VARS.RUNNING_TESTS_USER syndic_master_opts['root_dir'] = os.path.join(TMP, 'rootdir-syndic-master') syndic_master_opts['pki_dir'] = 'pki' pytest_stop_sending_events_file = os.path.join(TMP_ROOT_DIR, 'pytest_stop_sending_events_file_syndic_master') with salt.utils.files.fopen(pytest_stop_sending_events_file, 'w') as wfh: wfh.write('') syndic_master_opts['pytest_stop_sending_events_file'] = pytest_stop_sending_events_file # This is the syndic for master # Let's start with a copy of the syndic master configuration syndic_opts = copy.deepcopy(syndic_master_opts) # Let's update with the syndic configuration syndic_opts.update(salt.config._read_conf_file(os.path.join(RUNTIME_VARS.CONF_DIR, 'syndic'))) syndic_opts['cachedir'] = 'cache' syndic_opts['root_dir'] = os.path.join(TMP_ROOT_DIR) # This proxy connects to master proxy_opts = salt.config._read_conf_file(os.path.join(CONF_DIR, 'proxy')) proxy_opts['cachedir'] = 'cache' # proxy_opts['user'] = running_tests_user proxy_opts['root_dir'] = os.path.join(TMP, 'rootdir-proxy') proxy_opts['pki_dir'] = 'pki' proxy_opts['hosts.file'] = os.path.join(TMP, 'rootdir-proxy', 'hosts') proxy_opts['aliases.file'] = os.path.join(TMP, 'rootdir-proxy', 'aliases') if transport == 'tcp': master_opts['transport'] = 'tcp' minion_opts['transport'] = 'tcp' sub_minion_opts['transport'] = 'tcp' syndic_master_opts['transport'] = 'tcp' proxy_opts['transport'] = 'tcp' # Set up config options that require internal data master_opts['pillar_roots'] = syndic_master_opts['pillar_roots'] = { 'base': [ RUNTIME_VARS.TMP_PILLAR_TREE, os.path.join(FILES, 'pillar', 'base'), ] } minion_opts['pillar_roots'] = { 'base': [ RUNTIME_VARS.TMP_PILLAR_TREE, os.path.join(FILES, 'pillar', 'base'), ] } master_opts['file_roots'] = syndic_master_opts['file_roots'] = { 'base': [ os.path.join(FILES, 'file', 'base'), # Let's support runtime created files that can be used like: # salt://my-temp-file.txt RUNTIME_VARS.TMP_STATE_TREE ], # Alternate root to test __env__ choices 'prod': [ os.path.join(FILES, 'file', 'prod'), RUNTIME_VARS.TMP_PRODENV_STATE_TREE ] } minion_opts['file_roots'] = { 'base': [ os.path.join(FILES, 'file', 'base'), # Let's support runtime created files that can be used like: # salt://my-temp-file.txt RUNTIME_VARS.TMP_STATE_TREE ], # Alternate root to test __env__ choices 'prod': [ os.path.join(FILES, 'file', 'prod'), RUNTIME_VARS.TMP_PRODENV_STATE_TREE ] } master_opts.setdefault('reactor', []).append( { 'salt/minion/*/start': [ os.path.join(FILES, 'reactor-sync-minion.sls') ], } ) master_opts.setdefault('reactor', []).append( { 'salt/test/reactor': [ os.path.join(FILES, 'reactor-test.sls') ], } ) for opts_dict in (master_opts, syndic_master_opts): if 'ext_pillar' not in opts_dict: opts_dict['ext_pillar'] = [] if salt.utils.platform.is_windows(): opts_dict['ext_pillar'].append( {'cmd_yaml': 'type {0}'.format(os.path.join(FILES, 'ext.yaml'))}) else: opts_dict['ext_pillar'].append( {'cmd_yaml': 'cat {0}'.format(os.path.join(FILES, 'ext.yaml'))}) # all read, only owner write autosign_file_permissions = stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR for opts_dict in (master_opts, syndic_master_opts): # We need to copy the extension modules into the new master root_dir or # it will be prefixed by it new_extension_modules_path = os.path.join(opts_dict['root_dir'], 'extension_modules') if not os.path.exists(new_extension_modules_path): shutil.copytree( os.path.join( INTEGRATION_TEST_DIR, 'files', 'extension_modules' ), new_extension_modules_path ) opts_dict['extension_modules'] = os.path.join(opts_dict['root_dir'], 'extension_modules') # Copy the autosign_file to the new master root_dir new_autosign_file_path = os.path.join(opts_dict['root_dir'], 'autosign_file') shutil.copyfile( os.path.join(INTEGRATION_TEST_DIR, 'files', 'autosign_file'), new_autosign_file_path ) os.chmod(new_autosign_file_path, autosign_file_permissions) # Point the config values to the correct temporary paths for name in ('hosts', 'aliases'): optname = '{0}.file'.format(name) optname_path = os.path.join(TMP, name) master_opts[optname] = optname_path minion_opts[optname] = optname_path sub_minion_opts[optname] = optname_path syndic_opts[optname] = optname_path syndic_master_opts[optname] = optname_path proxy_opts[optname] = optname_path master_opts['runtests_conn_check_port'] = get_unused_localhost_port() minion_opts['runtests_conn_check_port'] = get_unused_localhost_port() sub_minion_opts['runtests_conn_check_port'] = get_unused_localhost_port() syndic_opts['runtests_conn_check_port'] = get_unused_localhost_port() syndic_master_opts['runtests_conn_check_port'] = get_unused_localhost_port() proxy_opts['runtests_conn_check_port'] = get_unused_localhost_port() for conf in (master_opts, minion_opts, sub_minion_opts, syndic_opts, syndic_master_opts, proxy_opts): if 'engines' not in conf: conf['engines'] = [] conf['engines'].append({'salt_runtests': {}}) if 'engines_dirs' not in conf: conf['engines_dirs'] = [] conf['engines_dirs'].insert(0, ENGINES_DIR) if 'log_handlers_dirs' not in conf: conf['log_handlers_dirs'] = [] conf['log_handlers_dirs'].insert(0, LOG_HANDLERS_DIR) conf['runtests_log_port'] = SALT_LOG_PORT # ----- Transcribe Configuration ----------------------------------------------------------------------------> for entry in os.listdir(RUNTIME_VARS.CONF_DIR): if entry in ('master', 'minion', 'sub_minion', 'syndic', 'syndic_master', 'proxy'): # These have runtime computed values and will be handled # differently continue entry_path = os.path.join(RUNTIME_VARS.CONF_DIR, entry) if os.path.isfile(entry_path): shutil.copy( entry_path, os.path.join(RUNTIME_VARS.TMP_CONF_DIR, entry) ) elif os.path.isdir(entry_path): shutil.copytree( entry_path, os.path.join(RUNTIME_VARS.TMP_CONF_DIR, entry) ) for entry in ('master', 'minion', 'sub_minion', 'syndic', 'syndic_master', 'proxy'): computed_config = copy.deepcopy(locals()['{0}_opts'.format(entry)]) with salt.utils.files.fopen(os.path.join(RUNTIME_VARS.TMP_CONF_DIR, entry), 'w') as fp_: salt.utils.yaml.safe_dump(computed_config, fp_, default_flow_style=False) sub_minion_computed_config = copy.deepcopy(sub_minion_opts) with salt.utils.files.fopen(os.path.join(RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR, 'minion'), 'w') as wfh: salt.utils.yaml.safe_dump(sub_minion_computed_config, wfh, default_flow_style=False) shutil.copyfile(os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'master'), os.path.join(RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR, 'master')) syndic_master_computed_config = copy.deepcopy(syndic_master_opts) with salt.utils.files.fopen(os.path.join(RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR, 'master'), 'w') as wfh: salt.utils.yaml.safe_dump(syndic_master_computed_config, wfh, default_flow_style=False) syndic_computed_config = copy.deepcopy(syndic_opts) with salt.utils.files.fopen(os.path.join(RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR, 'minion'), 'w') as wfh: salt.utils.yaml.safe_dump(syndic_computed_config, wfh, default_flow_style=False) shutil.copyfile(os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'master'), os.path.join(RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR, 'master')) # <---- Transcribe Configuration ----------------------------------------------------------------------------- # ----- Verify Environment ----------------------------------------------------------------------------------> master_opts = salt.config.master_config(os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'master')) minion_opts = salt.config.minion_config(os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'minion')) syndic_opts = salt.config.syndic_config( os.path.join(RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR, 'master'), os.path.join(RUNTIME_VARS.TMP_SYNDIC_MINION_CONF_DIR, 'minion'), ) sub_minion_opts = salt.config.minion_config(os.path.join(RUNTIME_VARS.TMP_SUB_MINION_CONF_DIR, 'minion')) syndic_master_opts = salt.config.master_config(os.path.join(RUNTIME_VARS.TMP_SYNDIC_MASTER_CONF_DIR, 'master')) proxy_opts = salt.config.proxy_config(os.path.join(RUNTIME_VARS.TMP_CONF_DIR, 'proxy')) RUNTIME_VARS.RUNTIME_CONFIGS['master'] = freeze(master_opts) RUNTIME_VARS.RUNTIME_CONFIGS['minion'] = freeze(minion_opts) RUNTIME_VARS.RUNTIME_CONFIGS['syndic'] = freeze(syndic_opts) RUNTIME_VARS.RUNTIME_CONFIGS['sub_minion'] = freeze(sub_minion_opts) RUNTIME_VARS.RUNTIME_CONFIGS['syndic_master'] = freeze(syndic_master_opts) RUNTIME_VARS.RUNTIME_CONFIGS['proxy'] = freeze(proxy_opts) verify_env([os.path.join(master_opts['pki_dir'], 'minions'), os.path.join(master_opts['pki_dir'], 'minions_pre'), os.path.join(master_opts['pki_dir'], 'minions_rejected'), os.path.join(master_opts['pki_dir'], 'minions_denied'), os.path.join(master_opts['cachedir'], 'jobs'), os.path.join(master_opts['root_dir'], 'cache', 'tokens'), os.path.join(syndic_master_opts['pki_dir'], 'minions'), os.path.join(syndic_master_opts['pki_dir'], 'minions_pre'), os.path.join(syndic_master_opts['pki_dir'], 'minions_rejected'), os.path.join(syndic_master_opts['cachedir'], 'jobs'), os.path.join(syndic_master_opts['root_dir'], 'cache', 'tokens'), os.path.join(master_opts['pki_dir'], 'accepted'), os.path.join(master_opts['pki_dir'], 'rejected'), os.path.join(master_opts['pki_dir'], 'pending'), os.path.join(syndic_master_opts['pki_dir'], 'accepted'), os.path.join(syndic_master_opts['pki_dir'], 'rejected'), os.path.join(syndic_master_opts['pki_dir'], 'pending'), os.path.join(minion_opts['pki_dir'], 'accepted'), os.path.join(minion_opts['pki_dir'], 'rejected'), os.path.join(minion_opts['pki_dir'], 'pending'), os.path.join(sub_minion_opts['pki_dir'], 'accepted'), os.path.join(sub_minion_opts['pki_dir'], 'rejected'), os.path.join(sub_minion_opts['pki_dir'], 'pending'), os.path.dirname(master_opts['log_file']), minion_opts['extension_modules'], sub_minion_opts['extension_modules'], sub_minion_opts['pki_dir'], master_opts['sock_dir'], syndic_master_opts['sock_dir'], sub_minion_opts['sock_dir'], minion_opts['sock_dir'], RUNTIME_VARS.TMP_STATE_TREE, RUNTIME_VARS.TMP_PILLAR_TREE, RUNTIME_VARS.TMP_PRODENV_STATE_TREE, TMP, ], RUNTIME_VARS.RUNNING_TESTS_USER, root_dir=master_opts['root_dir'], ) cls.master_opts = master_opts cls.minion_opts = minion_opts # cls.proxy_opts = proxy_opts cls.sub_minion_opts = sub_minion_opts cls.syndic_opts = syndic_opts cls.syndic_master_opts = syndic_master_opts cls.proxy_opts = proxy_opts
def setUpClass(cls): cls.model = freeze( { "interfaces": { "interface": { "Ethernet1": { "config": { "name": "Ethernet1", "description": "Interface Ethernet1", }, "subinterfaces": { "subinterface": { "0": { "config": { "index": 0, "description": "Subinterface Ethernet1.0", } }, "100": { "config": { "index": 100, "description": "Subinterface Ethernet1.100", } }, "900": { "config": { "index": 900, "description": "Subinterface Ethernet1.900", } }, } }, }, "Ethernet2": { "config": { "name": "Ethernet2", "description": "Interface Ethernet2", }, "subinterfaces": { "subinterface": { "400": { "config": { "index": 400, "description": "Subinterface Ethernet2.400", } } } }, }, } } } ) cls.defaults = freeze( { "interfaces": { "interface": { "*": { "config": {"mtu": 2048, "enabled": True}, "subinterfaces": { "subinterface": {"*": {"config": {"enabled": True}}} }, } } } } )