def prep_server(cls): ''' Set up all the webserver paths. Designed to be run once in a setUpClass function. ''' cls.root_dir = tempfile.mkdtemp(dir=TMP) cls.config_dir = os.path.join(cls.root_dir, 'config') cls.nginx_conf = os.path.join(cls.config_dir, 'nginx.conf') cls.uwsgi_conf = os.path.join(cls.config_dir, 'uwsgi.yml') cls.git_dir = os.path.join(cls.root_dir, 'git') cls.repo_dir = os.path.join(cls.git_dir, 'repos') cls.venv_dir = os.path.join(cls.root_dir, 'venv') cls.uwsgi_bin = os.path.join(cls.venv_dir, 'bin', 'uwsgi') cls.nginx_port = cls.uwsgi_port = get_unused_localhost_port() while cls.uwsgi_port == cls.nginx_port: # Ensure we don't hit a corner case in which two sucessive calls to # get_unused_localhost_port() return identical port numbers. cls.uwsgi_port = get_unused_localhost_port() cls.url = 'http://127.0.0.1:{port}/repo.git'.format(port=cls.nginx_port) cls.ext_opts = {'url': cls.url} # 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(cls, credential_param): cls.ext_opts[credential_param] = getattr(cls, credential_param)
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 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 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:{0}'.format(ret_port)} )
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:{0}".format(ret_port), })
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'])
def prep_server(cls): cls.sshd_config_dir = tempfile.mkdtemp(dir=TMP) cls.sshd_config = os.path.join(cls.sshd_config_dir, 'sshd_config') cls.sshd_port = get_unused_localhost_port() cls.url = 'ssh://{username}@127.0.0.1:{port}/~/repo.git'.format( username=cls.username, port=cls.sshd_port) home = '/root/.ssh' cls.ext_opts = { 'url': cls.url, 'privkey_nopass': os.path.join(home, cls.id_rsa_nopass), 'pubkey_nopass': os.path.join(home, cls.id_rsa_nopass + '.pub'), 'privkey_withpass': os.path.join(home, cls.id_rsa_withpass), 'pubkey_withpass': os.path.join(home, cls.id_rsa_withpass + '.pub'), 'passphrase': cls.passphrase}
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 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": pytest.skip("Test only applicable to the ZMQ transport")
def setUpClass(cls): ''' start tornado app on thread and wait till its running ''' cls.server_port = get_unused_localhost_port() cls.server_thread = threading.Thread(target=cls.webserver) cls.server_thread.daemon = True cls.server_thread.start() cls.archive_tar_source = 'http://localhost:{0}/custom.tar.gz'.format(cls.server_port) # check if tornado app is up port_closed = True while port_closed: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) result = sock.connect_ex(('127.0.0.1', cls.server_port)) if result == 0: port_closed = False
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': 'tcp', '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': 'tcp', 'master_ip': '127.0.0.1', 'auth_timeout': 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 = tornado.ioloop.IOLoop() cls.req_server_channel.post_fork(cls._handle_payload, io_loop=cls._server_io_loop) def run_loop_in_thread(loop): loop.make_current() loop.start() cls.server_thread = threading.Thread(target=run_loop_in_thread, args=(cls._server_io_loop, )) cls.server_thread.daemon = True cls.server_thread.start()
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 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(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 = zmq.eventloop.ioloop.ZMQIOLoop() 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 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': 'tcp', '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': 'tcp', '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.ReqServerChannel.factory( cls.master_config) cls.server_channel.pre_fork(cls.process_manager) cls.io_loop = tornado.ioloop.IOLoop() cls.stop = 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.stop, ), ) cls.server_thread.start()
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 = zmq.eventloop.ioloop.ZMQIOLoop() cls.io_loop.make_current() cls.server_channel.post_fork(cls._handle_payload, io_loop=cls.io_loop) cls.server_thread = threading.Thread(target=cls.io_loop.start) cls.server_thread.daemon = True cls.server_thread.start()
def setUpClass(cls): # pylint: disable=arguments-differ super(SSHDMixin, cls).setUpClass() try: log.info("%s: prep_server()", cls.__name__) cls.sshd_bin = salt.utils.path.which("sshd") cls.sshd_config_dir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP) cls.sshd_config = os.path.join(cls.sshd_config_dir, "sshd_config") cls.sshd_port = get_unused_localhost_port() cls.url = "ssh://{username}@127.0.0.1:{port}/~/repo.git".format( username=cls.username, port=cls.sshd_port ) cls.url_extra_repo = "ssh://{username}@127.0.0.1:{port}/~/extra_repo.git".format( username=cls.username, port=cls.sshd_port ) home = "/root/.ssh" cls.ext_opts = { "url": cls.url, "url_extra_repo": cls.url_extra_repo, "privkey_nopass": os.path.join(home, cls.id_rsa_nopass), "pubkey_nopass": os.path.join(home, cls.id_rsa_nopass + ".pub"), "privkey_withpass": os.path.join(home, cls.id_rsa_withpass), "pubkey_withpass": os.path.join(home, cls.id_rsa_withpass + ".pub"), "passphrase": cls.passphrase, } if cls.prep_states_ran is False: ret = cls.cls_run_function( "state.apply", mods="git_pillar.ssh", pillar={ "git_pillar": { "git_ssh": cls.git_ssh, "id_rsa_nopass": cls.id_rsa_nopass, "id_rsa_withpass": cls.id_rsa_withpass, "sshd_bin": cls.sshd_bin, "sshd_port": cls.sshd_port, "sshd_config_dir": cls.sshd_config_dir, "master_user": cls.user, "user": cls.username, } }, ) assert next(six.itervalues(ret))["result"] is True cls.prep_states_ran = True log.info("%s: States applied", cls.__name__) if cls.sshd_proc is not None: if not psutil.pid_exists(cls.sshd_proc.pid): log.info( "%s: sshd started but appears to be dead now. Will try to restart it.", cls.__name__, ) cls.sshd_proc = None if cls.sshd_proc is None: cls.sshd_proc = start_daemon( cls.sshd_bin, cls.sshd_config_dir, cls.sshd_port, SshdDaemon ) log.info("%s: sshd started", cls.__name__) except AssertionError: cls.tearDownClass() six.reraise(*sys.exc_info()) if cls.known_hosts_setup is False: known_hosts_ret = cls.cls_run_function( "ssh.set_known_host", user=cls.user, hostname="127.0.0.1", port=cls.sshd_port, enc="ssh-rsa", fingerprint="fd:6f:7f:5d:06:6b:f2:06:0d:26:93:9e:5a:b5:19:46", hash_known_hosts=False, fingerprint_hash_type="md5", ) if "error" in known_hosts_ret: cls.tearDownClass() raise AssertionError( "Failed to add key to {0} user's known_hosts " "file: {1}".format( cls.master_opts["user"], known_hosts_ret["error"] ) ) cls.known_hosts_setup = True
def test_cache_remote_file(self): ''' cp.cache_file ''' nginx_port = get_unused_localhost_port() url_prefix = 'http://localhost:{0}/'.format(nginx_port) temp_dir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP) self.addCleanup(shutil.rmtree, temp_dir, ignore_errors=True) nginx_root_dir = os.path.join(temp_dir, 'root') nginx_conf_dir = os.path.join(temp_dir, 'conf') nginx_conf = os.path.join(nginx_conf_dir, 'nginx.conf') nginx_pidfile = os.path.join(nginx_conf_dir, 'nginx.pid') file_contents = 'Hello world!' for dirname in (nginx_root_dir, nginx_conf_dir): os.makedirs(dirname) # Write the temp file with salt.utils.files.fopen(os.path.join(nginx_root_dir, 'actual_file'), 'w') as fp_: fp_.write(salt.utils.stringutils.to_str(file_contents)) # Write the nginx config with salt.utils.files.fopen(nginx_conf, 'w') as fp_: fp_.write(textwrap.dedent(salt.utils.stringutils.to_str( '''\ user root; worker_processes 1; error_log {nginx_conf_dir}/server_error.log; pid {nginx_pidfile}; events {{ worker_connections 1024; }} http {{ include /etc/nginx/mime.types; default_type application/octet-stream; access_log {nginx_conf_dir}/access.log; error_log {nginx_conf_dir}/error.log; server {{ listen {nginx_port} default_server; server_name cachefile.local; root {nginx_root_dir}; location ~ ^/301$ {{ return 301 /actual_file; }} location ~ ^/302$ {{ return 302 /actual_file; }} }} }}'''.format(**locals()) ))) self.run_function( 'cmd.run', [['nginx', '-c', nginx_conf]], python_shell=False ) with salt.utils.files.fopen(nginx_pidfile) as fp_: nginx_pid = int(fp_.read().strip()) nginx_proc = psutil.Process(pid=nginx_pid) self.addCleanup(nginx_proc.send_signal, signal.SIGQUIT) for code in ('', '301', '302'): url = url_prefix + (code or 'actual_file') log.debug('attempting to cache %s', url) ret = self.run_function('cp.cache_file', [url]) self.assertTrue(ret) with salt.utils.files.fopen(ret) as fp_: cached_contents = salt.utils.stringutils.to_unicode(fp_.read()) self.assertEqual(cached_contents, file_contents)
def setUpClass(cls): # pylint: disable=arguments-differ super(SSHDMixin, cls).setUpClass() try: log.info('%s: prep_server()', cls.__name__) cls.sshd_bin = salt.utils.path.which('sshd') cls.sshd_config_dir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP) cls.sshd_config = os.path.join(cls.sshd_config_dir, 'sshd_config') cls.sshd_port = get_unused_localhost_port() cls.url = 'ssh://{username}@127.0.0.1:{port}/~/repo.git'.format( username=cls.username, port=cls.sshd_port) cls.url_extra_repo = 'ssh://{username}@127.0.0.1:{port}/~/extra_repo.git'.format( username=cls.username, port=cls.sshd_port) home = '/root/.ssh' cls.ext_opts = { 'url': cls.url, 'url_extra_repo': cls.url_extra_repo, 'privkey_nopass': os.path.join(home, cls.id_rsa_nopass), 'pubkey_nopass': os.path.join(home, cls.id_rsa_nopass + '.pub'), 'privkey_withpass': os.path.join(home, cls.id_rsa_withpass), 'pubkey_withpass': os.path.join(home, cls.id_rsa_withpass + '.pub'), 'passphrase': cls.passphrase } if cls.prep_states_ran is False: ret = cls.cls_run_function('state.apply', mods='git_pillar.ssh', pillar={ 'git_pillar': { 'git_ssh': cls.git_ssh, 'id_rsa_nopass': cls.id_rsa_nopass, 'id_rsa_withpass': cls.id_rsa_withpass, 'sshd_bin': cls.sshd_bin, 'sshd_port': cls.sshd_port, 'sshd_config_dir': cls.sshd_config_dir, 'master_user': cls.user, 'user': cls.username } }) assert next(six.itervalues(ret))['result'] is True cls.prep_states_ran = True log.info('%s: States applied', cls.__name__) if cls.sshd_proc is not None: if not psutil.pid_exists(cls.sshd_proc.pid): log.info( '%s: sshd started but appears to be dead now. Will try to restart it.', cls.__name__) cls.sshd_proc = None if cls.sshd_proc is None: cls.sshd_proc = start_daemon(cls.sshd_bin, cls.sshd_config_dir, cls.sshd_port, SshdDaemon) log.info('%s: sshd started', cls.__name__) except AssertionError: cls.tearDownClass() six.reraise(*sys.exc_info()) if cls.known_hosts_setup is False: known_hosts_ret = cls.cls_run_function( 'ssh.set_known_host', user=cls.user, hostname='127.0.0.1', port=cls.sshd_port, enc='ssh-rsa', fingerprint='fd:6f:7f:5d:06:6b:f2:06:0d:26:93:9e:5a:b5:19:46', hash_known_hosts=False, fingerprint_hash_type='md5', ) if 'error' in known_hosts_ret: cls.tearDownClass() raise AssertionError( 'Failed to add key to {0} user\'s known_hosts ' 'file: {1}'.format(cls.master_opts['user'], known_hosts_ret['error'])) cls.known_hosts_setup = True
def setUpClass(cls): # pylint: disable=arguments-differ ''' Set up all the webserver paths. Designed to be run once in a setUpClass function. ''' super(WebserverMixin, cls).setUpClass() cls.root_dir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP) cls.config_dir = os.path.join(cls.root_dir, 'config') cls.nginx_conf = os.path.join(cls.config_dir, 'nginx.conf') cls.uwsgi_conf = os.path.join(cls.config_dir, 'uwsgi.yml') cls.git_dir = os.path.join(cls.root_dir, 'git') cls.repo_dir = os.path.join(cls.git_dir, 'repos') cls.venv_dir = os.path.join(cls.root_dir, 'venv') cls.uwsgi_bin = os.path.join(cls.venv_dir, 'bin', 'uwsgi') cls.nginx_port = cls.uwsgi_port = get_unused_localhost_port() while cls.uwsgi_port == cls.nginx_port: # Ensure we don't hit a corner case in which two sucessive calls to # get_unused_localhost_port() return identical port numbers. cls.uwsgi_port = get_unused_localhost_port() cls.url = 'http://127.0.0.1:{port}/repo.git'.format( port=cls.nginx_port) cls.url_extra_repo = 'http://127.0.0.1:{port}/extra_repo.git'.format( port=cls.nginx_port) cls.ext_opts = {'url': cls.url, 'url_extra_repo': cls.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(cls, credential_param): cls.ext_opts[credential_param] = getattr(cls, credential_param) auth_enabled = hasattr(cls, 'username') and hasattr(cls, 'password') pillar = { 'git_pillar': { 'config_dir': cls.config_dir, 'git_dir': cls.git_dir, 'venv_dir': cls.venv_dir, 'root_dir': cls.root_dir, 'nginx_port': cls.nginx_port, 'uwsgi_port': cls.uwsgi_port, 'auth_enabled': auth_enabled } } # Different libexec dir for git backend on Debian-based systems 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): cls.tearDownClass() raise AssertionError( '{} 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') try: if cls.prep_states_ran is False: ret = cls.cls_run_function('state.apply', mods='git_pillar.http', pillar=pillar) assert next(six.itervalues(ret))['result'] is True cls.prep_states_ran = True log.info('%s: States applied', cls.__name__) if cls.uwsgi_proc is not None: if not psutil.pid_exists(cls.uwsgi_proc.pid): log.warning( '%s: uWsgi started but appears to be dead now. Will try to restart it.', cls.__name__) cls.uwsgi_proc = None if cls.uwsgi_proc is None: cls.uwsgi_proc = start_daemon(cls.uwsgi_bin, cls.config_dir, cls.uwsgi_port, UwsgiDaemon) log.info('%s: %s started', cls.__name__, cls.uwsgi_bin) if cls.nginx_proc is not None: if not psutil.pid_exists(cls.nginx_proc.pid): log.warning( '%s: nginx started but appears to be dead now. Will try to restart it.', cls.__name__) cls.nginx_proc = None if cls.nginx_proc is None: cls.nginx_proc = start_daemon('nginx', cls.config_dir, cls.nginx_port, NginxDaemon) log.info('%s: nginx started', cls.__name__) except AssertionError: cls.tearDownClass() six.reraise(*sys.exc_info())
def setUpClass(cls): # pylint: disable=arguments-differ """ Set up all the webserver paths. Designed to be run once in a setUpClass function. """ super(WebserverMixin, cls).setUpClass() cls.root_dir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP) cls.config_dir = os.path.join(cls.root_dir, "config") cls.nginx_conf = os.path.join(cls.config_dir, "nginx.conf") cls.uwsgi_conf = os.path.join(cls.config_dir, "uwsgi.yml") cls.git_dir = os.path.join(cls.root_dir, "git") cls.repo_dir = os.path.join(cls.git_dir, "repos") cls.venv_dir = os.path.join(cls.root_dir, "venv") cls.uwsgi_bin = os.path.join(cls.venv_dir, "bin", "uwsgi") cls.nginx_port = cls.uwsgi_port = get_unused_localhost_port() while cls.uwsgi_port == cls.nginx_port: # Ensure we don't hit a corner case in which two sucessive calls to # get_unused_localhost_port() return identical port numbers. cls.uwsgi_port = get_unused_localhost_port() cls.url = "http://127.0.0.1:{port}/repo.git".format( port=cls.nginx_port) cls.url_extra_repo = "http://127.0.0.1:{port}/extra_repo.git".format( port=cls.nginx_port) cls.ext_opts = {"url": cls.url, "url_extra_repo": cls.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(cls, credential_param): cls.ext_opts[credential_param] = getattr(cls, credential_param) auth_enabled = hasattr(cls, "username") and hasattr(cls, "password") pillar = { "git_pillar": { "config_dir": cls.config_dir, "git_dir": cls.git_dir, "venv_dir": cls.venv_dir, "root_dir": cls.root_dir, "nginx_port": cls.nginx_port, "uwsgi_port": cls.uwsgi_port, "auth_enabled": auth_enabled, } } # Different libexec dir for git backend on Debian-based systems 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): cls.tearDownClass() raise AssertionError( "{} 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") try: if cls.prep_states_ran is False: ret = cls.cls_run_function("state.apply", mods="git_pillar.http", pillar=pillar) assert next(six.itervalues(ret))["result"] is True cls.prep_states_ran = True log.info("%s: States applied", cls.__name__) if cls.uwsgi_proc is not None: if not psutil.pid_exists(cls.uwsgi_proc.pid): log.warning( "%s: uWsgi started but appears to be dead now. Will try to restart it.", cls.__name__, ) cls.uwsgi_proc = None if cls.uwsgi_proc is None: cls.uwsgi_proc = start_daemon(cls.uwsgi_bin, cls.config_dir, cls.uwsgi_port, UwsgiDaemon) log.info("%s: %s started", cls.__name__, cls.uwsgi_bin) if cls.nginx_proc is not None: if not psutil.pid_exists(cls.nginx_proc.pid): log.warning( "%s: nginx started but appears to be dead now. Will try to restart it.", cls.__name__, ) cls.nginx_proc = None if cls.nginx_proc is None: cls.nginx_proc = start_daemon("nginx", cls.config_dir, cls.nginx_port, NginxDaemon) log.info("%s: nginx started", cls.__name__) except AssertionError: cls.tearDownClass() six.reraise(*sys.exc_info())