def test_no_local_network(testdir): testdir.makepyfile(""" import pytest @pytest.mark.requires_network def test_one(): assert True """) mock_socket = mock.MagicMock() mock_socket.bind = mock.MagicMock(side_effect=socket.error) with mock.patch( "saltfactories.utils.ports.get_unused_localhost_port", side_effect=[ ports.get_unused_localhost_port(), ports.get_unused_localhost_port() ], ): with mock.patch("socket.socket", return_value=mock_socket): res = testdir.runpytest_inprocess("-p", "no:salt-factories-log-server") res.assert_outcomes(skipped=1) try: res.stdout.no_fnmatch_line("*PytestUnknownMarkWarning*") except AttributeError: # pragma: no cover # PyTest 4.6.x from _pytest.outcomes import Failed with pytest.raises(Failed): res.stdout.fnmatch_lines([ "*PytestUnknownMarkWarning*", ])
def salt_secondary_master(request, salt_factories): # # Enable a secondary Salt master so we can disable follow_symlinks # publish_port = get_unused_localhost_port() ret_port = get_unused_localhost_port() config_defaults = { "open_mode": True, "transport": request.config.getoption("--transport"), } config_overrides = { "interface": "127.0.0.1", "fileserver_followsymlinks": False, "publish_port": publish_port, "ret_port": ret_port, } factory = salt_factories.salt_master_daemon( "secondary-master", defaults=config_defaults, overrides=config_overrides, extra_cli_arguments_after_first_start_failure=["--log-level=debug"], ) with factory.started(start_timeout=120): yield factory
def default_config(root_dir, minion_id, config_defaults=None, config_overrides=None, master_port=None): if config_defaults is None: config_defaults = salt.config.DEFAULT_MINION_OPTS.copy() config_defaults.pop("user", None) conf_dir = root_dir / "conf" conf_dir.mkdir(parents=True, exist_ok=True) conf_file = str(conf_dir / "minion") _config_defaults = { "id": minion_id, "conf_file": conf_file, "root_dir": str(root_dir), "interface": "127.0.0.1", "master": "127.0.0.1", "master_port": master_port or ports.get_unused_localhost_port(), "tcp_pub_port": ports.get_unused_localhost_port(), "tcp_pull_port": ports.get_unused_localhost_port(), "pidfile": "run/minion.pid", "pki_dir": "pki", "cachedir": "cache", "sock_dir": "run/minion", "log_file": "logs/minion.log", "log_level_logfile": "debug", "loop_interval": 0.05, #'multiprocessing': False, "log_fmt_console": "%(asctime)s,%(msecs)03.0f [%(name)-17s:%(lineno)-4d][%(levelname)-8s][%(processName)18s(%(process)d)] %(message)s", "log_fmt_logfile": "[%(asctime)s,%(msecs)03.0f][%(name)-17s:%(lineno)-4d][%(levelname)-8s][%(processName)18s(%(process)d)] %(message)s", "hash_type": "sha256", "transport": "zeromq", "pytest-minion": { "log": { "prefix": "{{cli_name}}({})".format(minion_id) }, }, "acceptance_wait_time": 0.5, "acceptance_wait_time_max": 5, } # Merge in the initial default options with the internal _config_defaults salt.utils.dictupdate.update(config_defaults, _config_defaults, merge_lists=True) if config_overrides: # Merge in the default options with the minion_config_overrides salt.utils.dictupdate.update(config_defaults, config_overrides, merge_lists=True) return config_defaults
def test_get_unused_localhost_port_cached(): """ Tests that test_get_unused_localhost_port only returns unique ports on consecutive calls """ num_calls = 10 start_port = 1000 # The ports we're gonna get back ports = [] for port in range(start_port, start_port + num_calls): for _ in range(num_calls): # We make sure each port is repeated consecutively ports.append(port) # Hold a reference to the list of unique ports unique = set(ports) # This list will hold all ports that the function returns got_ports = [] # We'll get the unique ports with mock.patch( "saltfactories.utils.socket.socket", new_callable=functools.partial(MockedCreateSocket, ports), ): for _ in range(num_calls): got_ports.append( ports_utils.get_unused_localhost_port(use_cache=True)) assert len(got_ports) == num_calls assert set(got_ports) == unique with mock.patch( "saltfactories.utils.socket.socket", new_callable=functools.partial(MockedCreateSocket, ports + ports), ): for _ in range(num_calls): with pytest.raises(IndexError): # we won't have enough ports got_ports.append( ports_utils.get_unused_localhost_port(use_cache=True)) # Since we couldn't get repeated ports, got_ports remains as it was assert len(got_ports) == num_calls assert set(got_ports) == unique # If we don't cache the port, we'll get repeated ports with mock.patch( "saltfactories.utils.socket.socket", new_callable=functools.partial(MockedCreateSocket, ports), ): for _ in range(num_calls): got_ports.append(ports_utils.get_unused_localhost_port()) assert len(got_ports) == 2 * len(unique) assert set(got_ports) == unique
def test_get_unused_localhost_port_unique(): """ Tests that test_get_unused_localhost_port only returns unique ports on consecutive calls """ num_calls = 10 start_port = 1000 # The ports we're gonna get back ports = [] for port in range(start_port, start_port + num_calls): for _ in range(num_calls): # We make sure each port is repeated consecutively ports.append(port) # Hold a reference to the list of unique ports unique = set(ports) # This list will hold all ports that the function returns got_ports = [] # We'll get the unique ports with mock.patch("socket.socket", new_callable=functools.partial(MockedCreateSocket, ports)) as mocked_socket: for _ in range(num_calls): got_ports.append( ports_utils.get_unused_localhost_port(cached_seconds=1)) assert len(got_ports) == num_calls assert set(got_ports) == unique # Let's get ports again. Since not enough time has passed, we won't get any ports with mock.patch("socket.socket", new_callable=functools.partial(MockedCreateSocket, ports + ports)) as mocked_socket: for _ in range(num_calls): with pytest.raises(IndexError): # we won't have enough ports got_ports.append( ports_utils.get_unused_localhost_port(cached_seconds=1)) # Since we couldn't get repeated ports, got_ports remains as it was assert len(got_ports) == num_calls assert set(got_ports) == unique # Now, if we sleep one second, the cached ports will be gone and we'll get repeated ports time.sleep(1) with mock.patch("socket.socket", new_callable=functools.partial(MockedCreateSocket, ports)) as mocked_socket: for _ in range(num_calls): got_ports.append( ports_utils.get_unused_localhost_port(cached_seconds=1)) assert len(got_ports) == 2 * len(unique) assert set(got_ports) == unique
def master_config(tmp_path): master_conf = salt.config.master_config("") master_conf["id"] = "master" master_conf["root_dir"] = str(tmp_path) master_conf["sock_dir"] = str(tmp_path) master_conf["interface"] = "127.0.0.1" master_conf["publish_port"] = get_unused_localhost_port() master_conf["ret_port"] = get_unused_localhost_port() master_conf["pki_dir"] = str(tmp_path / "pki") os.makedirs(master_conf["pki_dir"]) salt.crypt.gen_keys(master_conf["pki_dir"], "master", 4096) minions_keys = os.path.join(master_conf["pki_dir"], "minions") os.makedirs(minions_keys) yield master_conf
def test_no_local_network(): mock_socket = mock.MagicMock() mock_socket.bind = mock.MagicMock(side_effect=socket.error) with mock.patch( "saltfactories.utils.ports.get_unused_localhost_port", side_effect=[ ports.get_unused_localhost_port(), ports.get_unused_localhost_port() ], ): with mock.patch("socket.socket", return_value=mock_socket): skip_reason = markers.skip_if_no_local_network() assert skip_reason is not None assert skip_reason == "No local network was detected"
def default_config( cls, root_dir, proxy_minion_id, config_defaults=None, config_overrides=None, master=None ): if config_defaults is None: config_defaults = {} master_id = master_port = None if master is not None: master_id = master.id master_port = master.config["ret_port"] # Match transport if not set config_defaults.setdefault("transport", master.config["transport"]) conf_dir = root_dir / "conf" conf_dir.mkdir(parents=True, exist_ok=True) conf_file = str(conf_dir / "proxy") _config_defaults = { "id": proxy_minion_id, "conf_file": conf_file, "root_dir": str(root_dir), "interface": "127.0.0.1", "master": "127.0.0.1", "master_port": master_port or ports.get_unused_localhost_port(), "tcp_pub_port": ports.get_unused_localhost_port(), "tcp_pull_port": ports.get_unused_localhost_port(), "pidfile": "run/proxy.pid", "pki_dir": "pki", "cachedir": "cache", "sock_dir": "run/proxy", "log_file": "logs/proxy.log", "log_level_logfile": "debug", "loop_interval": 0.05, "log_fmt_console": "%(asctime)s,%(msecs)03.0f [%(name)-17s:%(lineno)-4d][%(levelname)-8s][%(processName)18s(%(process)d)] %(message)s", "log_fmt_logfile": "[%(asctime)s,%(msecs)03.0f][%(name)-17s:%(lineno)-4d][%(levelname)-8s][%(processName)18s(%(process)d)] %(message)s", "proxy": {"proxytype": "dummy"}, "pytest-minion": { "master-id": master_id, "log": {"prefix": "{}(id={!r})".format(cls.__name__, proxy_minion_id)}, }, } # Merge in the initial default options with the internal _config_defaults salt.utils.dictupdate.update(config_defaults, _config_defaults, merge_lists=True) if config_overrides: # Merge in the default options with the proxy_config_overrides salt.utils.dictupdate.update(config_defaults, config_overrides, merge_lists=True) return config_defaults
def __init__(self, *args, **kwargs): config_dir = kwargs.pop("config_dir") serve_port = kwargs.pop("serve_port", None) super().__init__(*args, **kwargs) self.config_dir = config_dir self.serve_port = serve_port or ports.get_unused_localhost_port() self._write_default_config()
def skip_if_no_local_network(): """ Helper function to check for existing local network Returns: str: The reason for the skip. None: Should not be skipped. """ check_port = ports.get_unused_localhost_port() has_local_network = False try: with contextlib.closing( socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as pubsock: pubsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) pubsock.bind(("", check_port)) has_local_network = True except socket.error: # I wonder if we just have IPV6 support? try: with contextlib.closing( socket.socket(socket.AF_INET6, socket.SOCK_STREAM)) as pubsock: pubsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) pubsock.bind(("", check_port)) has_local_network = True except socket.error: # Let's continue pass if has_local_network is False: return "No local network was detected"
def __attrs_post_init__(self): self.store = deque(maxlen=10000) self.address = "tcp://127.0.0.1:{}".format(ports.get_unused_localhost_port()) self.running_event = threading.Event() self.running_thread = threading.Thread(target=self._run) self.sentinel = msgpack.dumps(None) self.auth_event_handlers = weakref.WeakValueDictionary()
def setUp(self): self.listen_on = "127.0.0.1" self.port = get_unused_localhost_port() self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind((self.listen_on, self.port)) self.sock.listen(1)
def setUp(self): self.test_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) port = get_unused_localhost_port() self.test_server.bind(("127.0.0.1", port)) self.test_server.settimeout(2) self.logger = logging.getLogger("test_logstash_logger") self.logger.setLevel(logging.DEBUG) self.logger.addHandler(DatagramLogstashHandler("127.0.0.1", port))
def master(salt_factories): config_defaults = { "rest_tornado": {"port": ports.get_unused_localhost_port(), "disable_ssl": True} } factory = salt_factories.get_salt_master_daemon( random_string("master-"), config_defaults=config_defaults ) with factory.started(): yield factory
def __init__(self, timeout=60, auth_events_callback=None): self.store = deque(maxlen=10000) self.address = "tcp://127.0.0.1:{}".format( ports.get_unused_localhost_port()) self.timeout = timeout self.auth_events_callback = auth_events_callback self.running_event = threading.Event() self.running_thread = threading.Thread(target=self._run) self.sentinel = msgpack.dumps(None)
def setUp(self): self.context = zmq.Context() port = get_unused_localhost_port() self.zmq_server = self.context.socket(zmq.SUB) self.zmq_server.setsockopt(zmq.SUBSCRIBE, b"") self.zmq_server.bind("tcp://127.0.0.1:{}".format(port)) self.logger = logging.getLogger("test_logstash_logger") self.logger.setLevel(logging.DEBUG) self.logger.addHandler(ZMQLogstashHander("tcp://127.0.0.1:{}".format(port)))
def salt_message_client(): io_loop_mock = MagicMock(spec=salt.ext.tornado.ioloop.IOLoop) io_loop_mock.call_later.side_effect = lambda *args, **kwargs: (args, kwargs) client = salt.transport.tcp.MessageClient( {}, "127.0.0.1", get_unused_localhost_port(), io_loop=io_loop_mock ) try: yield client finally: client.close()
def setUpClass(cls): ret_port = get_unused_localhost_port() publish_port = get_unused_localhost_port() tcp_master_pub_port = get_unused_localhost_port() tcp_master_pull_port = get_unused_localhost_port() tcp_master_publish_pull = get_unused_localhost_port() tcp_master_workers = get_unused_localhost_port() cls.master_config = cls.get_temp_config( "master", **{ "transport": "zeromq", "auto_accept": True, "ret_port": ret_port, "publish_port": publish_port, "tcp_master_pub_port": tcp_master_pub_port, "tcp_master_pull_port": tcp_master_pull_port, "tcp_master_publish_pull": tcp_master_publish_pull, "tcp_master_workers": tcp_master_workers, "sign_pub_messages": False, }) salt.master.SMaster.secrets["aes"] = { "secret": multiprocessing.Array( ctypes.c_char, six.b(salt.crypt.Crypticle.generate_key_string()), ), } cls.minion_config = cls.get_temp_config( "minion", **{ "transport": "zeromq", "master_ip": "127.0.0.1", "master_port": ret_port, "auth_timeout": 5, "auth_tries": 1, "master_uri": "tcp://127.0.0.1:{}".format(ret_port), })
def test_no_local_network(testdir): testdir.makepyfile(""" import pytest @pytest.mark.requires_network def test_one(): assert True """) mock_socket = mock.MagicMock() mock_socket.bind = mock.MagicMock(side_effect=socket.error) with mock.patch( "saltfactories.utils.ports.get_unused_localhost_port", side_effect=[ ports.get_unused_localhost_port(), ports.get_unused_localhost_port() ], ): with mock.patch("socket.socket", return_value=mock_socket): res = testdir.runpytest_inprocess("-p", "no:salt-factories-log-server") res.assert_outcomes(skipped=1) res.stdout.no_fnmatch_line("*PytestUnknownMarkWarning*")
def setUpClass(cls): ret_port = get_unused_localhost_port() publish_port = get_unused_localhost_port() tcp_master_pub_port = get_unused_localhost_port() tcp_master_pull_port = get_unused_localhost_port() tcp_master_publish_pull = get_unused_localhost_port() tcp_master_workers = get_unused_localhost_port() cls.master_config = cls.get_temp_config( "master", **{ "transport": "zeromq", "auto_accept": True, "ret_port": ret_port, "publish_port": publish_port, "tcp_master_pub_port": tcp_master_pub_port, "tcp_master_pull_port": tcp_master_pull_port, "tcp_master_publish_pull": tcp_master_publish_pull, "tcp_master_workers": tcp_master_workers, } ) cls.minion_config = salt.config.minion_config( os.path.join(RUNTIME_VARS.TMP_CONF_DIR, "minion") ) cls.minion_config = cls.get_temp_config( "minion", **{ "transport": "zeromq", "master_ip": "127.0.0.1", "master_port": ret_port, "master_uri": "tcp://127.0.0.1:{0}".format(ret_port), } ) cls.process_manager = salt.utils.process.ProcessManager( name="ReqServer_ProcessManager" ) cls.server_channel = salt.transport.server.PubServerChannel.factory( cls.master_config ) cls.server_channel.pre_fork(cls.process_manager) # we also require req server for auth cls.req_server_channel = salt.transport.server.ReqServerChannel.factory( cls.master_config ) cls.req_server_channel.pre_fork(cls.process_manager) cls._server_io_loop = salt.ext.tornado.ioloop.IOLoop() cls.evt = threading.Event() cls.req_server_channel.post_fork( cls._handle_payload, io_loop=cls._server_io_loop ) cls.server_thread = threading.Thread( target=run_loop_in_thread, args=(cls._server_io_loop, cls.evt) ) cls.server_thread.start()
def datagram_server(): logger = logging.getLogger("test_logstash_logger") server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) port = get_unused_localhost_port() handler = DatagramLogstashHandler("127.0.0.1", port) try: server.bind(("127.0.0.1", port)) server.settimeout(2) logger.setLevel(logging.DEBUG) logger.addHandler(handler) yield server finally: logger.removeHandler(handler) server.close()
def apply_pre_start_states(self, salt_call_cli, testclass, username): if self.listen_port in self.check_ports: self.check_ports.remove(self.listen_port) if self.listen_port in self.listen_ports: self.listen_ports.remove(self.listen_port) self.listen_port = get_unused_localhost_port() self.check_ports.append(self.listen_port) self.listen_ports.append(self.listen_port) url = "ssh://{username}@127.0.0.1:{port}/~/repo.git".format( username=testclass.username, port=self.listen_port) url_extra_repo = "ssh://{username}@127.0.0.1:{port}/~/extra_repo.git".format( username=testclass.username, port=self.listen_port) home = "/root/.ssh" testclass.ext_opts = { "url": url, "url_extra_repo": url_extra_repo, "privkey_nopass": os.path.join(home, testclass.id_rsa_nopass), "pubkey_nopass": os.path.join(home, testclass.id_rsa_nopass + ".pub"), "privkey_withpass": os.path.join(home, testclass.id_rsa_withpass), "pubkey_withpass": os.path.join(home, testclass.id_rsa_withpass + ".pub"), "passphrase": testclass.passphrase, } ret = salt_call_cli.run( "state.apply", mods="git_pillar.ssh", pillar={ "git_pillar": { "git_ssh": testclass.git_ssh, "id_rsa_nopass": testclass.id_rsa_nopass, "id_rsa_withpass": testclass.id_rsa_withpass, "sshd_bin": self.get_script_path(), "sshd_port": self.listen_port, "sshd_config_dir": str(self.config_dir), "master_user": username, "user": testclass.username, } }, _timeout=240, ) if ret.exitcode != 0: pytest.fail("Failed to apply the 'git_pillar.ssh' state") if next(iter(ret.json.values()))["result"] is not True: pytest.fail("Failed to apply the 'git_pillar.ssh' state")
def apply_pre_start_states(self, salt_call_cli, testclass, root_dir): if self.listen_port in self.check_ports: self.check_ports.remove(self.listen_port) if self.listen_port in self.listen_ports: self.listen_ports.remove(self.listen_port) self.listen_port = get_unused_localhost_port() self.check_ports.append(self.listen_port) self.listen_ports.append(self.listen_port) config_dir = os.path.join(root_dir, "config") git_dir = os.path.join(root_dir, "git") testclass.repo_dir = repo_dir = os.path.join(git_dir, "repos") venv_dir = os.path.join(root_dir, "venv") uwsgi_bin = os.path.join(venv_dir, "bin", "uwsgi") pillar = { "git_pillar": { "config_dir": config_dir, "git_dir": git_dir, "venv_dir": venv_dir, "root_dir": root_dir, "uwsgi_port": self.listen_port, } } # Different libexec dir for git backend on Debian and FreeBSD-based systems if salt.utils.platform.is_freebsd(): git_core = "/usr/local/libexec/git-core" else: git_core = "/usr/libexec/git-core" if not os.path.exists(git_core): git_core = "/usr/lib/git-core" if not os.path.exists(git_core): pytest.fail( "{} not found. Either git is not installed, or the test " "class needs to be updated.".format(git_core) ) pillar["git_pillar"]["git-http-backend"] = os.path.join( git_core, "git-http-backend" ) ret = salt_call_cli.run( "state.apply", mods="git_pillar.http.uwsgi", pillar=pillar, _timeout=120 ) if ret.exitcode != 0: pytest.fail("Failed to apply the 'git_pillar.http.uwsgi' state") if next(iter(ret.json.values()))["result"] is not True: pytest.fail("Failed to apply the 'git_pillar.http.uwsgi' state")
def __attrs_post_init__(self): if self.authorized_keys is None: self.authorized_keys = [] if self.sshd_config_dict is None: self.sshd_config_dict = {} if self.listen_address is None: self.listen_address = "127.0.0.1" if self.listen_port is None: self.listen_port = ports.get_unused_localhost_port() self.check_ports = [self.listen_port] if isinstance(self.config_dir, str): self.config_dir = pathlib.Path(self.config_dir) elif not isinstance(self.config_dir, pathlib.Path): # A py local path? self.config_dir = pathlib.Path(self.config_dir.strpath) self.config_dir.chmod(0o0700) authorized_keys_file = self.config_dir / "authorized_keys" # Let's generate the client key self.client_key = self._generate_client_ecdsa_key() with open("{}.pub".format(self.client_key)) as rfh: pubkey = rfh.read().strip() log.debug("SSH client pub key: %r", pubkey) self.authorized_keys.append(pubkey) # Write the authorized pub keys to file with open(str(authorized_keys_file), "w") as wfh: wfh.write("\n".join(self.authorized_keys)) authorized_keys_file.chmod(0o0600) with open(str(authorized_keys_file)) as rfh: log.debug("AuthorizedKeysFile contents:\n%s", rfh.read()) _default_config = { "ListenAddress": self.listen_address, "PermitRootLogin": "******" if running_username() == "root" else "no", "ChallengeResponseAuthentication": "no", "PasswordAuthentication": "no", "PubkeyAuthentication": "yes", "PrintMotd": "no", "PidFile": self.config_dir / "sshd.pid", "AuthorizedKeysFile": authorized_keys_file, } if self.sshd_config_dict: _default_config.update(self.sshd_config_dict) self.sshd_config = _default_config self._write_config() super().__attrs_post_init__()
def setUpClass(cls): overrides = { "publish_port": get_unused_localhost_port(), "ret_port": get_unused_localhost_port(), "tcp_master_pub_port": get_unused_localhost_port(), "tcp_master_pull_port": get_unused_localhost_port(), "tcp_master_publish_pull": get_unused_localhost_port(), "tcp_master_workers": get_unused_localhost_port(), "runtests_conn_check_port": get_unused_localhost_port(), "runtests_log_port": get_unused_localhost_port(), } overrides["pytest_engine_port"] = overrides["runtests_conn_check_port"] temp_config = AdaptedConfigurationTestCaseMixin.get_temp_config( "master", **overrides) cls.root_dir = temp_config["root_dir"] cls.config_dir = os.path.dirname(temp_config["conf_file"]) if temp_config["transport"] == "tcp": raise SkipTest("Test only applicable to the ZMQ transport")
def zmq_server(): logger = logging.getLogger("test_logstash_logger") context = zmq.Context() server = context.socket(zmq.SUB) port = get_unused_localhost_port() handler = ZMQLogstashHander("tcp://127.0.0.1:{}".format(port)) try: server.setsockopt(zmq.SUBSCRIBE, b"") server.bind("tcp://127.0.0.1:{}".format(port)) logger.setLevel(logging.DEBUG) logger.addHandler(handler) yield server finally: logger.removeHandler(handler) server.close() context.term()
def test_multiple_start_stops(salt_factories): config_defaults = { "rest_tornado": {"port": ports.get_unused_localhost_port(), "disable_ssl": True} } master = salt_factories.get_salt_master_daemon( random_string("master-"), config_defaults=config_defaults ) with master.started(): factory = master.get_salt_api_daemon() assert factory.is_running() is False pid = None with factory.started(): assert factory.is_running() is True pid = factory.pid assert factory.is_running() is False with factory.started(): assert factory.is_running() is True assert factory.pid != pid
async def test_ipc_connect_sync_wrapped(io_loop, tmp_path): """ Ensure IPCMessageSubscriber.connect gets wrapped by salt.utils.asynchronous.SyncWrapper. """ if salt.utils.platform.is_windows(): socket_path = get_unused_localhost_port() else: socket_path = str(tmp_path / "noexist.ipc") subscriber = salt.utils.asynchronous.SyncWrapper( salt.transport.ipc.IPCMessageSubscriber, args=(socket_path, ), kwargs={"io_loop": io_loop}, loop_kwarg="io_loop", ) with pytest.raises(salt.ext.tornado.iostream.StreamClosedError): # Don't `await subscriber.connect()`, that's the purpose of the SyncWrapper subscriber.connect()
def setUpClass(cls): if not hasattr(cls, "_handle_payload"): return ret_port = get_unused_localhost_port() publish_port = get_unused_localhost_port() tcp_master_pub_port = get_unused_localhost_port() tcp_master_pull_port = get_unused_localhost_port() tcp_master_publish_pull = get_unused_localhost_port() tcp_master_workers = get_unused_localhost_port() cls.master_config = cls.get_temp_config( "master", **{ "transport": "zeromq", "auto_accept": True, "ret_port": ret_port, "publish_port": publish_port, "tcp_master_pub_port": tcp_master_pub_port, "tcp_master_pull_port": tcp_master_pull_port, "tcp_master_publish_pull": tcp_master_publish_pull, "tcp_master_workers": tcp_master_workers, } ) cls.minion_config = cls.get_temp_config( "minion", **{ "transport": "zeromq", "master_ip": "127.0.0.1", "master_port": ret_port, "auth_timeout": 5, "auth_tries": 1, "master_uri": "tcp://127.0.0.1:{0}".format(ret_port), } ) cls.process_manager = salt.utils.process.ProcessManager( name="ReqServer_ProcessManager" ) cls.server_channel = salt.transport.server.ReqServerChannel.factory( cls.master_config ) cls.server_channel.pre_fork(cls.process_manager) cls.io_loop = salt.ext.tornado.ioloop.IOLoop() cls.evt = threading.Event() cls.server_channel.post_fork(cls._handle_payload, io_loop=cls.io_loop) cls.server_thread = threading.Thread( target=run_loop_in_thread, args=(cls.io_loop, cls.evt) ) cls.server_thread.start()
def apply_pre_start_states(self, salt_call_cli, testclass, root_dir): if self.listen_port in self.check_ports: self.check_ports.remove(self.listen_port) if self.listen_port in self.listen_ports: self.listen_ports.remove(self.listen_port) self.listen_port = get_unused_localhost_port() self.check_ports.append(self.listen_port) self.listen_ports.append(self.listen_port) config_dir = os.path.join(root_dir, "config") git_dir = os.path.join(root_dir, "git") url = "http://127.0.0.1:{port}/repo.git".format(port=self.listen_port) url_extra_repo = "http://127.0.0.1:{port}/extra_repo.git".format( port=self.listen_port) ext_opts = {"url": url, "url_extra_repo": url_extra_repo} # Add auth params if present (if so this will trigger the spawned # server to turn on HTTP basic auth). for credential_param in ("user", "password"): if hasattr(testclass, credential_param): ext_opts[credential_param] = getattr(testclass, credential_param) testclass.ext_opts = ext_opts testclass.nginx_port = self.listen_port auth_enabled = hasattr(testclass, "username") and hasattr( testclass, "password") pillar = { "git_pillar": { "config_dir": config_dir, "git_dir": git_dir, "uwsgi_port": self.uwsgi_port, "nginx_port": self.listen_port, "auth_enabled": auth_enabled, } } ret = salt_call_cli.run("state.apply", mods="git_pillar.http.nginx", pillar=pillar) if ret.exitcode != 0: pytest.fail("Failed to apply the 'git_pillar.http.nginx' state") if next(iter(ret.json.values()))["result"] is not True: pytest.fail("Failed to apply the 'git_pillar.http.nginx' state")