Пример #1
0
def check_redis_instances(step, instances_count, instance_type, serv_as):
    server = getattr(world, serv_as)
    instances = getattr(world, 'redis_instances', {})
    count = 0
    for instance in instances:
        if CONF.feature.platform in ['cloudstack', 'idcf']:
            cloud = Cloud()
            node = cloud.get_node(server)
            ip = filter(lambda x: x.address == server.public_ip, node.driver.ex_list_public_ip())[0]
            try:
                rule = node.driver.ex_add_port_forwarding_rule(node, ip, 'TCP', instance, instance)
            except:
                rules = node.driver.ex_list_port_forwarding_rule()
                rule = filter(lambda x: x.public_port == instance and x.address == ip, rules)[0]
            LOG.info('Rule for open port add: %s %s - %s' % (ip, instance, instance))
        info = {}
        try:
            LOG.debug('Try connect to redis instance: %s:%s:%s' % (server.public_ip, instance, instances[instance]))
            r = redis.Redis(host=server.public_ip, port=instance, password=instances[instance], socket_timeout=5)
            info = r.info()
        except redis.ConnectionError, e:
            LOG.error('Connection to redis: %s:%s with password %s is FAILED' % (server.public_ip, instance,
                                                                                 instances[instance]))
            raise redis.ConnectionError('Connection to redis: %s:%s with password %s is FAILED' % (server.public_ip, instance,
                                                                                                   instances[instance]))
        finally:
Пример #2
0
def action_on_redis(step, action, instance_number, serv_as):
    server = getattr(world, serv_as)
    instances = getattr(world, 'redis_instances', {})
    instance = sorted(instances.items())[int(instance_number)-1]
    if CONF.feature.platform in ['cloudstack', 'idcf']:
        cloud = Cloud()
        node = cloud.get_node(server)
        ip = filter(lambda x: x.address == server.public_ip, node.driver.ex_list_public_ip())[0]
        try:
            rule = node.driver.ex_add_port_forwarding_rule(node, ip, 'TCP', instance[0], instance[0])
        except:
            rules = node.driver.ex_list_port_forwarding_rule()
            rule = filter(lambda x: x.public_port == instance[0] and x.address == ip, rules)[0]
        LOG.info('Rule for open port add: %s %s - %s' % (ip, instance[0], instance[0]))
    r = redis.Redis(host=server.public_ip, port=instance[0], password=instance[1], socket_timeout=5, db=0)
    if action == 'write':
        LOG.info('Insert test key to %s:%s' % (server.public_ip, instance[0]))
        r.set('test_key', 'test_value')
    elif action == 'read':
        LOG.info('Read test key from %s:%s' % (server.public_ip, instance[0]))
        data = r.get('test_key')
        if not data == 'test_value':
            LOG.error('Receive bad key value from redis instance: %s:%s' % (server.public_ip, instance[0]))
            raise AssertionError('Receive bad key value from redis instance: %s:%s' % (server.public_ip, instance[0]))
    if CONF.feature.platform in ['cloudstack', 'idcf']:
        node.driver.ex_delete_port_forwarding_rule(node, rule)
        LOG.info('Rule for open port was delete')
Пример #3
0
def assert_cf_work(step, serv_as):
    time.sleep(180)
    server = getattr(world, serv_as)
    cloud = Cloud()
    cloud_serv = cloud.node_from_server(server)
    out = cloud_serv.run("/bin/bash -c 'source /usr/local/rvm/scripts/rvm; vmc info'")[0]
    world.assert_not_in("VMware's Cloud Application Platform", out, 'CF client not work, message: %s' % out)
Пример #4
0
def check_count_redis_instances(step, instances_count, serv_as):
    server = getattr(world, serv_as)
    c = Cloud()
    node = c.get_node(server)
    out = node.run('ps -A | grep redis-server')
    if not len(out[0].splitlines()) == int(instances_count):
        LOG.error('Redis processes: %s' % out[0])
        raise AssertionError('Invalid redis processes count, must be: %s but %s' % (instances_count, len(out[0].splitlines())))
Пример #5
0
def add_test_app(step, serv_as):
    server = getattr(world, serv_as)
    cloud = Cloud()
    node = cloud.node_from_server(server)
    node.run('mkdir env')
    cont = resources('scripts/env.rb')
    node.put(path='/root/env/env.rb', content=cont.get())
    out = node.run("/bin/bash -c 'source /usr/local/rvm/scripts/rvm; vmc login --email [email protected] --passwd password; echo Y | vmc push testapp --url %s --mem 64 --path /root/env/'" % world.D1)[0]
    world.assert_not_in('Starting Application: OK', out, 'Application is not starting: %s' % out)
Пример #6
0
def check_processes(step, count, serv_as):
    time.sleep(60)
    serv = getattr(world, serv_as)
    cl = Cloud()
    node = cl.get_node(serv)
    list_proc = node.run("ps aux | grep scalarizr")[0]
    c = 0
    for pr in list_proc.splitlines():
        if "bin/scalarizr" in pr:
            c += 1
    LOG.info("Scalarizr count of processes %s" % c)
    world.assert_not_equal(c, int(count), "Scalarizr processes is: %s but processes \n%s" % (c, list_proc))
Пример #7
0
def given_server_in_cloud(step, mbeh):
    n = getattr(world, 'cloud_server', None)
    if n:
        n.destroy()
    cloud = Cloud()
    LOG.info('Create node in cloud')
    if mbeh == 'mbeh1':
        image = images(CONF.main.platform).filter({'dist': get_scalr_dist_name(CONF.main.dist), 'behavior':'mysql2'}).first()
    elif mbeh == 'mbeh2':
        image = images(CONF.main.platform).filter({'dist': get_scalr_dist_name(CONF.main.dist), 'behavior':'www'}).first()
    LOG.debug('Use image: %s' % image)
    node = cloud.create_node(image=image.keys()[0], userdata='scm-branch=%s' % CONF.main.branch)
    setattr(world, 'cloud_server', node)
Пример #8
0
def assert_at_user_on_server(cloud: Cloud, server: api.Server, expected_user: str):
    node = cloud.get_node(server)
    cmd = 'net user' if CONF.feature.dist.is_windows else 'cut -d : -f 1 /etc/passwd'
    with node.remote_connection() as conn:
        user_list = conn.run(cmd).std_out.split()
        assert expected_user in user_list, \
            f'User {expected_user} was not found on the server! User list output: {user_list}'
Пример #9
0
def get_mount_table(cloud: Cloud, server: Server) -> tp.Dict[str, str]:
    LOG.info('Save mount table from server "%s"' % server.id)
    node = cloud.get_node(server)
    mount_table = node.run('mount').std_out.splitlines()
    mount_table = {x.split()[2]: x.split()[0] for x in mount_table if x}
    LOG.debug('Mount table:\n %s' % mount_table)
    return mount_table
Пример #10
0
 def test_webhooks(self, context: dict, cloud: Cloud, farm: Farm, servers: dict, testenv, ssl_verify: bool, webhooks: list, expected_results: list):
     server = servers.get('F1')
     params = {
         "scalr.system.webhooks.scalr_labs_workflow_engine": True,
         "scalr.system.webhooks.ssl_verify": ssl_verify,
         "scalr.system.webhooks.retry_interval": 5,
         "scalr.system.webhooks.use_proxy": False}
     lib_scalr.update_scalr_config(testenv, params)
     testenv.restart_service("workflow-engine")
     testenv.restart_service("zmq_service")
     node = cloud.get_node(server)
     node.put_file("/tmp/default",
                   resources('configs/nginx_to_flask_proxy.conf').get().decode("utf-8"))
     node.put_file("/tmp/prepare_flask.sh",
                   resources('scripts/prepare_flask.sh').get().decode("utf-8"))
     node.put_file('webhooks.py',
                   resources('scripts/webhooks.py').get().decode("utf-8"))  # Put flask script
     with node.remote_connection() as conn:
         # Run preparation script
         conn.run("sudo bash /tmp/prepare_flask.sh")
         # Run flask in background process
         conn.run("gunicorn -D -w 1 --bind localhost:5000 webhooks:app")
     lib_apache.assert_check_http_get_answer(server)
     lib_webhooks.configure_webhooks(webhooks, server, farm, context)
     result = lib_node.execute_command(cloud, server, 'szradm --fire-event AccountEvent')
     assert not result.std_err, "Command szradm --fire-event AccountEvent failed with %s" % result.std_err
     lib_webhooks.assert_webhooks(context['test_webhooks'], expected_results, server_id=server.id)
     assert not testenv.check_service_log("workflow-engine", "Traceback"), "Found Traceback in workflow-engine service log!"
Пример #11
0
 def test_chef_deployment_linux(self, context: dict, cloud: Cloud, servers: dict):
     """Verify chef executed fine"""
     server = servers['M1']
     node = cloud.get_node(server)
     context['chef_deployment_time'] = provision.get_chef_bootstrap_stat(node)
     lib_node.assert_process_has_options(cloud, server, process='memcached', options='-m 1024')
     lib_node.assert_process_has_options(cloud, server, process='chef-client', options='--daemonize')
     provision.assert_chef_node_name_equal_hostname(cloud, server)
Пример #12
0
 def test_checking_config_changes(self, cloud: Cloud, servers: dict):
     """Checking config changes: INTERVAL"""
     server = servers['M1']
     node = cloud.get_node(server)
     interval = 15
     provision.change_chef_client_interval_value(node, interval)
     provision.assert_chef_client_interval_value(node, interval)
     provision.assert_chef_runs_time(node, interval)
Пример #13
0
def assert_scalarizr_log_errors(cloud: Cloud, server: Server, log_type: str = None):
    """Check scalarizr log for errors"""
    log_type = log_type or 'debug'
    node = cloud.get_node(server)
    if CONF.feature.dist.is_windows:
        validate_scalarizr_log_errors(cloud, node, windows=True, server=server, log_type=log_type)
    else:
        validate_scalarizr_log_errors(cloud, node, log_type=log_type)
Пример #14
0
 def test_chef_after_resume_linux(self, context: dict, cloud: Cloud, servers: dict, farm: Farm):
     """Verify chef not executed after resume"""
     server = servers['M1']
     node = cloud.get_node(server)
     assert context['chef_deployment_time'] == provision.get_chef_bootstrap_stat(node), \
         'Chef was started after resume!'
     provision.check_process_status(node, 'memcached', False)
     lib_node.assert_process_has_options(cloud, server, process='chef-client', options='--daemonize')
     provision.assert_chef_node_name_equal_hostname(cloud, server)
Пример #15
0
def assert_szr_terminated_in_log(cloud: Cloud, server: Server):
    # TODO: PP > consolidate win/linux methods
    node = cloud.get_node(server)
    if CONF.feature.ci_repo == 'buildbot':
        out = node.run("findstr /c:\"Scalarizr terminated\" \"C:\Program Files\Scalarizr\\var\log\scalarizr_debug.log\"")
    else:
        out = node.run("findstr /c:\"Scalarizr terminated\" \"C:\opt\scalarizr\\var\log\scalarizr_debug.log\"")
    if 'Scalarizr terminated' in out.std_out:
        return True
    raise AssertionError("Not see 'Scalarizr terminated' in debug log")
Пример #16
0
def validate_string_in_file(cloud: Cloud, server: Server, file_path: str, value: str, invert: bool = False):
    LOG.info('Verify file "%s" in %s %s "%s"' % (file_path, server.id,
                                                 'does not contain' if invert else 'contains',
                                                 value))
    node = cloud.get_node(server)
    out = node.run('cat %s | grep %s' % (file_path, value)).std_out.strip()
    assert bool(out) ^ invert, \
        'File %s %s: %s. Result of grep: %s' % (file_path,
                                                'contains' if invert else 'does not contain',
                                                value, out)
Пример #17
0
 def test_chef_solo_bootstrapping(self, context: dict, cloud: Cloud, farm: Farm, role_options: str):
     """Bootstrapping role with chef-solo"""
     lib_farm.clear(farm)
     farm.terminate()
     lib_farm.add_role_to_farm(context, farm, role_options=[role_options])
     farm.launch()
     server = lib_server.wait_server_status(context, cloud, farm, status=ServerStatus.RUNNING)
     node = cloud.get_node(server)
     lib_server.assert_file_exist(node, f'C:\{role_options}')
     provision.assert_script_data_deleted(cloud, server)
Пример #18
0
def assert_chef_node_name_equal_hostname(cloud: Cloud, server: api.Server):
    hostname = lib_server.get_hostname_by_server_format(server)
    node = cloud.get_node(server)
    command = CONF.feature.dist.is_windows \
        and 'findstr node_name c:\\chef\\client.rb' \
        or 'cat /etc/chef/client.rb | grep node_name'
    with node.remote_connection() as conn:
        result = conn.run(command).std_out
        node_name = result.strip().split()[1][1:-1]
        if not node_name == hostname:
            raise AssertionError(f'Chef node_name "{node_name}" != hostname on server "{hostname}"')
Пример #19
0
def szradm_execute_command(command: str, cloud: Cloud, server: Server, format_output: bool=True):
    command = format_output and f"{command} --format=json" or command
    if CONF.feature.dist.id == 'coreos':
        command = f'PATH=$PATH:/opt/bin; {command}'
    LOG.info(f'Execute the command: {command} a remote host: {server.id}')
    node = cloud.get_node(server)
    with node.remote_connection() as conn:
        result = conn.run(command)
        if result.status_code:
            raise AssertionError(f"An error has occurred while execute szradm:\n {out.std_err}")
        return format_output and json.loads(result.std_out) or result.std_out
Пример #20
0
 def test_bootstrapping_form_chef_role(self, context: dict, cloud: Cloud, farm: Farm):
     """Bootstrapping from chef role"""
     lib_farm.clear(farm)
     farm.terminate()
     lib_farm.add_role_to_farm(context, farm, role_options=['winchef-role'])
     farm.launch()
     server = lib_server.wait_server_status(context, cloud, farm, status=ServerStatus.RUNNING)
     node = cloud.get_node(server)
     lib_server.assert_file_exist(node, 'C:\chef_result_file')
     lib_server.assert_scalarizr_log_errors(cloud, server)
     lifecycle.assert_szr_version_last(server)
     lifecycle.assert_hostname(server)
Пример #21
0
def set_iptables_rule(cloud: Cloud, server: Server, port: tp.Union[int, tuple, list]):
    """Insert iptables rule in the top of the list"""
    LOG.info('Insert iptables rule to server %s for opening port %s' % (server, port))
    node = cloud.get_node(server)
    my_ip = get_external_local_ip()
    LOG.info('My IP address: %s' % my_ip)
    if isinstance(port, (tuple, list)):
        if len(port) == 2:
            port = ':'.join(str(x) for x in port)
        else:
            port = ','.join(str(x) for x in port)
    node.run('iptables -I INPUT -p tcp -s %s --dport %s -j ACCEPT' % (my_ip, port))
Пример #22
0
def agent_restart(cloud: Cloud, server: Server):
    # TODO: PP > consolidate win/linux methods
    node = cloud.get_node(server)
    with node.remote_connection() as conn:
        LOG.info('Restart scalarizr via winrm')
        LOG.debug('Stop scalarizr')
        out = conn.run('net stop Scalarizr')
        time.sleep(3)
        LOG.debug(out)
        out = conn.run('net start Scalarizr')
        LOG.debug(out)
        time.sleep(15)
Пример #23
0
def get_config_from_message(cloud: Cloud, server: Server, config_group: str, message: str) -> dict:
    node = cloud.get_node(server)
    LOG.info(f'Get messages from server {server.id}')
    messages = lib_server.get_szr_messages(node)
    msg_id = next(filter(lambda x: x['name'] == message, messages))['id']
    LOG.info(f'Message id for {message} is {msg_id}')
    cmd = f'szradm message-details {msg_id} --json'
    if CONF.feature.dist.id == 'coreos':
        cmd = "/opt/bin/" + cmd
    message_details = json.loads(node.run(cmd).std_out)['body']
    LOG.info(f'Message details is {message_details}')
    LOG.info(f'Returning message part {config_group}')
    return message_details[config_group]
Пример #24
0
def assert_path_exist(cloud: Cloud, server: Server, path: str):
    """Validate path exist in server"""
    LOG.info(f'Verify path {path} exist in server {server.id}')
    node = cloud.get_node(server)
    with node.remote_connection() as conn:
        for attempt in range(5):
            out = conn.run('/bin/ls %s' % path)
            if out.status_code == 0:
                break
            time.sleep(15)
        else:
            LOG.error(f'Path {path} does not exist in server {server.id}')
            raise AssertionError(f'Path {path} does not exist in server {server.id}')
Пример #25
0
def assert_chef_bootstrap_failed(cloud: Cloud, server: api.Server):
    node = cloud.get_node(server)
    assertion_msg = "Chef bootstrap marker not found in scalarizr_debug.log"
    if CONF.feature.dist.is_windows:
        failure_marker = 'chef-client" exited with code 1'
        cmd = 'findstr /C:"Command \\"C:\opscode\chef\\bin\chef-client\\" exited with code 1"' \
              ' "C:\opt\scalarizr\\var\log\scalarizr_debug.log"'
        assert failure_marker in node.run(cmd).std_out, assertion_msg
    else:
        failure_markers = [
            'Command "/usr/bin/chef-client" exited with code 1',
            'Command /usr/bin/chef-client exited with code 1']
        assert any(node.run(f'grep {m} /var/log/scalarizr_debug.log').std_out.strip() for m in failure_markers), \
            assertion_msg
Пример #26
0
 def test_bootstrapping_with_chef(self, context: dict, cloud: Cloud, farm: Farm, servers: dict):
     """Bootstrapping with chef"""
     lib_farm.add_role_to_farm(context, farm, role_options=['winchef'])
     farm.launch()
     server = lib_server.wait_server_status(context, cloud, farm, status=ServerStatus.RUNNING)
     servers['M1'] = server
     lib_server.assert_scalarizr_log_errors(cloud, server)
     lifecycle.assert_szr_version_last(server)
     provision.assert_node_exists_on_chef_server(server)
     orchestration.assert_recipes_in_runlist(server, ['windows_file_create', 'revizorenv', 'revizor_chef_multi'])
     node = cloud.get_node(server)
     lib_server.assert_file_exist(node, 'C:\chef_result_file')
     lib_server.assert_file_exist(node, 'C:\changed_result')
     provision.assert_chef_node_name_equal_hostname(cloud, server)
     provision.assert_chef_log_contains_text(server, "revizor_chef_variable=REVIZOR_CHEF_VARIABLE_VALUE_WORK")
Пример #27
0
def delete_volume(cloud: Cloud, device_id: str):
    LOG.info('Delete volume: %s' % device_id)
    volume = [v for v in cloud.list_volumes() if v.id == device_id]
    if volume:
        volume = volume[0]
    else:
        raise AssertionError('Can\'t found Volume in cloud with ID: %s' % device_id)
    for i in range(10):
        try:
            cloud._driver._conn.destroy_volume(volume)
            break
        except Exception as e:
            if 'attached' in e.message:
                LOG.warning('Volume %s currently attached to server' % device_id)
                time.sleep(60)
Пример #28
0
def create_partitions_on_volume(cloud: Cloud, server: Server, mnt_point: str):
    script_name = 'create_partitions.sh'
    script_src = resources(Path('scripts', script_name)).get().decode()
    path = Path('/tmp', script_name)
    node = cloud.get_node(server)

    LOG.info('Creating partitions table for volume on %s' % mnt_point)
    node.put_file(str(path), script_src % mnt_point)
    out = node.run(f'source {path}')

    partition_table = out.std_out.strip('\n').splitlines()[-4:]
    LOG.debug('Created partitions table for volume:\n%s' % '\n'.join(partition_table))
    assert all(line.startswith('/dev/') for line in partition_table), \
        'Create volume partitions failed: %s' % out.std_err
    LOG.info('Partitions table for volume was successfully created')
Пример #29
0
def assert_script_data_deleted(cloud: Cloud, server: api.Server):
    node = cloud.get_node(server)
    server.scriptlogs.reload()
    LOG.info('Check script executed data was deleted')
    if not server.scriptlogs:
        raise AssertionError("No orchestration logs found on %s" % server.id)
    task_dir = server.scriptlogs[0].execution_id.replace('-', '')
    if CONF.feature.dist.is_windows:
        cmd = f'dir c:\\opt\\scalarizr\\var\\lib\\tasks\\{task_dir} /b /s /ad | findstr /e "\\bin \\data"'
    else:
        cmd = f'find /var/lib/scalarizr/tasks/{task_dir} -type d -regex ".*/\\(bin\\|data\\)"'
    with node.remote_connection() as conn:
        result = conn.run(cmd)
        assert not result.std_err, f"Command: {cmd} execution error:\n {result.std_err}"
        folders = [l for l in result.std_out.splitlines() if l.strip()]
        assert not folders,  f"Find script data {folders} on {server.id}"
Пример #30
0
def assert_attached_disks_size(cloud: Cloud, server: Server, disks: tp.List[tp.Tuple[str, str, int]]):
    node = cloud.get_node(server)
    out = node.run('wmic volume get Caption,Capacity,Label').std_out
    server_disks = [line.split() for line in out.splitlines() if line.strip()][1:]
    for d, label, size in disks:
        for disk in server_disks:
            if disk[1] == d:
                server_size = int(disk[0]) // 1000000000
                if server_size != size:
                    raise AssertionError("Disk %s is of wrong size  - %s " % (disk[1], server_size))
                if len(disk) > 2 and disk[2] not in label:
                    raise AssertionError("Disk %s has incorrect or no label '%s'. Should be '%s'." % (
                        disk[1], disk[2], label))
                break
        else:
            raise AssertionError("Disk not found! All server disks %s" % server_disks)
Пример #31
0
def initialize_world():
    setattr(world, 'test_start_time', datetime.now())
    c = Cloud()
    setattr(world, 'cloud', c)