def not_in_config(step, serv_as, serv_config):
    time.sleep(180)
    server = getattr(world, serv_as)
    server_config = getattr(world, serv_config)
    cloud_serv = world.cloud.get_node(server_config)
    wait_until(check_not_in_config, args=(cloud_serv, server), timeout=1200, error_text='%s with IP %s in config' %
                                                                                        (serv_as, server.private_ip))

def check_options_in_nginx_upstream(step, option, serv_as):
    server = getattr(world, serv_as)
    node = world.cloud.get_node(server)
    LOG.info('Verify %s in proxies config' % option)
    wait_until(check_config_for_option,
               args=[node, 'proxies.include', option],
               timeout=180, error_text='Parameter \'%s\' not found in proxies.include' % option)

def assert_wait_servers(step, serv_count):
    role = world.get_role()
    serv_count = int(serv_count)
    timeout = 60 * 15 * serv_count
    LOG.info('Wait %s servers, timeout %s seconds' % (serv_count, timeout))
    wait_until(world.wait_servers_running, args=(role, serv_count), timeout=timeout,
               error_text='Not see %s servers running' % serv_count)

def farm(request: FixtureRequest) -> Farm:
    if CONF.main.farm_id is None:
        LOG.info('Farm ID not set, create a new farm for test')
        test_farm = Farm.create(f'tmprev-{datetime.now().strftime("%d%m%H%M%f")}',
                                'Revizor farm for tests\n'
                                f'RV_BRANCH={CONF.feature.branch}\n'
                                f'RV_PLATFORM={CONF.feature.platform.name}\n'
                                f'RV_DIST={CONF.feature.dist.dist}\n')
        CONF.main.farm_id = test_farm.id
    else:
        LOG.info(f'Farm ID is set in config, use it: {CONF.main.farm_id}')
        test_farm = Farm.get(CONF.main.farm_id)
        lib_farm.clear(test_farm)
    LOG.info(f'Returning test farm: {test_farm.id}')
    try:
        yield test_farm
    finally:
        failed_count = request.session.testsfailed
        LOG.info('Failed tests: %s' % failed_count)
        if (failed_count == 0 and CONF.feature.stop_farm) or (CONF.feature.stop_farm and CONF.scalr.te_id):
            LOG.info('Clear and stop farm...')
            test_farm.terminate()
            IMPL.farm.clear_roles(test_farm.id)
            if test_farm.name.startswith('tmprev'):
                LOG.info('Delete working temporary farm')
                try:
                    LOG.info('Wait all servers in farm terminated before delete')
                    wait_until(lib_server.farm_servers_state,
                               args=(test_farm, 'terminated'),
                               timeout=1800,
                               error_text='Servers in farm not terminated too long')
                    test_farm.destroy()
                except Exception as e:
                    LOG.warning(f'Farm cannot be deleted: {str(e)}')
        LOG.info('Farm finalize complete')

def check_proxy_in_nginx_config(step, www_serv, vhost_name):
    serv = getattr(world, www_serv)
    domain = getattr(world, vhost_name)
    node = world.cloud.get_node(serv)
    LOG.info('Proxies config for server %s' % serv.public_ip)
    wait_until(check_config_for_option,
               args=[node, 'proxies.include', domain.name],
               timeout=180,
               error_text='Not see domain %s in proxies.include' % domain)

def check_log(step, serv_as):
    server = getattr(world, serv_as)
    node = world.cloud.get_node(server)
    LOG.info("Check scalarizr log for  termination")
    wait_until(
        world.check_text_in_scalarizr_log,
        timeout=300,
        args=(node, "Scalarizr terminated"),
        error_text='Not see "Scalarizr terminated" in debug log',
    )

def assert_server_event(server: Server, events_type: list):
    """Assert server events"""
    LOG.info('Check "%s" events were fired  by %s' % (events_type, server.id))
    err_msg = '"%s" events were not fired by %s' % (events_type, server.id)
    wait_until(
        is_events_fired,
        args=(server, events_type),
        timeout=300,
        logger=LOG,
        error_text=err_msg)

def assert_check_upstream_after_delete(step, www_serv, have, app_serv):
    server = getattr(world, app_serv)
    www_serv = getattr(world, www_serv)
    if have:
        LOG.info('Check if upstream not have %s in list' % server.id)
        wait_until(world.wait_upstream_in_config, args=(world.cloud.get_node(www_serv), server.private_ip, False),
                   timeout=180, error_text="Upstream %s in list" % server.private_ip)
    else:
        LOG.info('Check if upstream have %s in list' % server.id)
        wait_until(world.wait_upstream_in_config, args=(world.cloud.get_node(www_serv), server.private_ip),
                   timeout=180, error_text="Upstream %s not in list" % server.private_ip)

def check_ebs_status(step, serv_as, status):
    """Check EBS storage status"""
    if CONF.main.driver == Platform.GCE:
        return
    time.sleep(30)
    server = getattr(world, serv_as)
    wait_until(
        world.check_server_storage,
        args=(serv_as, status),
        timeout=300,
        error_text="Volume from server %s is not %s" % (server.id, status),
    )

def assert_check_upstream_after_delete(step, www_serv, have, app_serv, private_ip=None):
    server = getattr(world, app_serv)
    www_serv = getattr(world, www_serv)
    ip = getattr(world, '%s_private_ip' % app_serv) if private_ip else server.private_ip
    if have:
        LOG.info('Check if upstream not have %s in list' % server.id)
        wait_until(world.wait_upstream_in_config, args=(world.cloud.get_node(www_serv), ip, False),
                   timeout=180, error_text="Server %s (%s) in upstream list" % (server.id, ip))
    else:
        LOG.info('Check if upstream have %s in list' % server.id)
        wait_until(world.wait_upstream_in_config, args=(world.cloud.get_node(www_serv), ip),
                   timeout=180, error_text="Server %s (%s) not in upstream list" % (server.id, ip))

def listen_only(step, port, serv_as):
    world.farm.servers.reload()
    servers = [s for s in world.farm.servers if s.status == 'Running']
    server = getattr(world, serv_as)
    port = port.strip()
    wait_until(world.check_open_port, args=(server, port.strip()), timeout=600, error_text="Port %s is not open" %
                                                                                           port)
    for serv in servers:
        if serv.id == server.id:
            continue
        time.sleep(60)
        res = world.check_open_port(serv, port.strip())
        world.assert_exist(res, 'Port %s is open, but must be closed in server %s' % (port, serv.id))

def app_server_should_be_clean(step, serv_as):
    server = getattr(world, serv_as)
    node = world.cloud.get_node(server)
    ip = '127.0.0.1:80'
    LOG.info('Check if default ip is in list')
    wait_until(world.wait_upstream_in_config, args=(node,ip),
               timeout=180,error_text="Server %s (%s) not in upstream list" % (server.id, ip))
    out = node.run('cat /etc/nginx/app-servers.include').std_out
    ips = re.findall(r"((?:\d+\.?){4}:\d+)", out)
    if not len(ips) == 1:
        raise AssertionError('In default app-servers.include must be only one host, but it: %s (%s)' % (len(ips), ips))
    if not ips[0] == ip:
        raise AssertionError('First host in default app-server.include is not localhost, it: %s' % ips)

def wait_voume_snapshot(step):
    # NOTE: migrated
    def is_snapshot_completed(**kwargs):
        status = IMPL.aws_tools.snapshots_list(**kwargs)[0]['status']
        LOG.info('Wait for volume snapshot completed, actual state is: %s ' % status)
        return status == "completed"

    wait_until(
        is_snapshot_completed,
        kwargs=dict(
            location=CONF.feature.platform.location,
            snapshot_id=getattr(world, 'volume_snapshot_id')),
        timeout=600,
        logger=LOG)

def add_objects(step, obj, serv_as):
    """
    Insert data to RabbitMQ server
    """
    serv = getattr(world, serv_as)
    node = world.cloud.get_node(serv)
    password = wait_until(world.wait_rabbitmq_cp, timeout=360, error_text="Not see detail to rabbitmq panel")['password']
    setattr(world, 'rabbitmq_password', password)
    LOG.info('Rabbitmq password: %s' % password)
    if obj == 'user':
        node.run('rabbitmqctl add_user testuser testpassword')
        LOG.info('Add user scalr to rabbitmq')
    elif obj == 'vhost':
        node.run('rabbitmqctl add_vhost testvhost')
        LOG.info('Add vhost "testvhost" to rabbitmq')
    elif obj == 'queue':
        credentials = pika.PlainCredentials('scalr', password)
        connection = pika.BlockingConnection(pika.ConnectionParameters(credentials=credentials, host=str(serv.public_ip)))
        channel = connection.channel()
        channel.queue_declare(queue='test_queue', durable=True)
        LOG.info('Add queue "test_queue" to rabbitmq')
    elif obj == 'message':
        credentials = pika.PlainCredentials('scalr', password)
        connection = pika.BlockingConnection(pika.ConnectionParameters(credentials=credentials, host=str(serv.public_ip)))
        channel = connection.channel()
        channel.basic_publish(exchange='', routing_key='test_queue', body='super test message',
                                                properties=pika.BasicProperties(delivery_mode=2,))
        LOG.info('Add message to rabbitmq')

def assert_role_task_created(step,  timeout=1400):
    platform = CONF.feature.platform
    res = wait_until(
        IMPL.bundle.assert_role_task_created,
        args=(world.bundle_task.get('id'), ),
        timeout=timeout,
        error_text="Time out error. Can't create role with behaviors: %s." % CONF.feature.behaviors)
    if res.get('failure_reason'):
        raise AssertionError("Can't create role: %s. Error: %s" % (res['role_id'], res['failure_reason']))
    LOG.info('New role was created successfully with Role_id: %s.' % res['role_id'])
    world.bundled_role_id = res['role_id']
    #Remove port forward rule for Cloudstack
    if platform.is_cloudstack:
        LOG.info('Deleting a Port Forwarding Rule. IP:%s, Port:%s' % (world.forwarded_port, world.ip))
        if not world.cloud.close_port(world.cloud_server, world.forwarded_port, ip=world.ip):
            raise AssertionError("Can't delete a port forwarding Rule.")
        LOG.info('Port Forwarding Rule was successfully removed.')
    #Destroy virtual machine in Cloud
    LOG.info('Destroying virtual machine %s in Cloud' % world.cloud_server.id)
    try:
        if not world.cloud_server.destroy():
            raise AssertionError("Can't destroy node with id: %s." % world.cloud_server.id)
    except Exception as e:
        if platform.is_gce:
            if world.cloud_server.name in str(e):
                pass
        else:
            raise
    LOG.info('Virtual machine %s was successfully destroyed.' % world.cloud_server.id)
    world.cloud_server = None

def install_scalarizr_to_server(server: Server, cloud: Cloud,
                                use_sysprep: bool = False,
                                use_rv_to_branch: bool = False,
                                custom_branch: str = None) -> str:
    """
    Install scalarizr to linux or windows server from branch
    :param server: Server for scalarizr
    :param cloud: Cloud object
    :param use_sysprep: If True and windows, run sysprep
    :param use_rv_to_branch: Get branch from RV_TO_BRANCH
    :param custom_branch: Use custom branch
    :return: Installed scalarizr version
    """
    if server:
        server.reload()
    LOG.debug('Cloud server not found get node from server')
    node = wait_until(cloud.get_node, args=(server,), timeout=300, logger=LOG)
    LOG.debug('Node get successfully: %s' % node)
    rv_branch = CONF.feature.branch
    rv_to_branch = CONF.feature.to_branch
    if use_rv_to_branch:
        branch = rv_to_branch
    elif custom_branch:
        branch = custom_branch
    else:
        branch = rv_branch
    LOG.info('Installing scalarizr from branch %s' % branch)
    scalarizr_ver = node.install_scalarizr(branch=branch)
    if use_sysprep and node.os.is_windows:
        run_sysprep(cloud, node)
    LOG.debug('Scalarizr %s was successfully installed' % scalarizr_ver)
    return scalarizr_ver

def assert_expect_server(step, role, serv_as):
    spec = 'running'
    world.farm.roles.reload()
    role_id = filter(lambda x: role.strip() in x.role.behaviors, world.farm.roles)[0]
    role_id = role_id.role_id
    server = wait_until(world.check_server_status, args=(spec, role_id, True), timeout=1500,
                        error_text="I'm not see this %s state in server" % spec)
    setattr(world, serv_as, server)

def assert_check_resolv(step, domain_as, serv_as, timeout=1800):
    domain = getattr(world, domain_as)
    serv = getattr(world, serv_as)

    def check_new_ip(domain_name, ip):
        try:
            actual_ip = wait_until(world.check_resolving, args=(domain_name,), timeout=timeout,
                              error_text="Not see domain resolve")
        except Exception:
            return False
        if ip == actual_ip:
            return True
        else:
            LOG.debug('Actual IP is not server IP: %s != %s' % (actual_ip, ip))
            return False
    wait_until(check_new_ip, args=(domain.name, serv.public_ip), timeout=timeout,
                           error_text="Domain resolve not new IP")

def assert_build_completed(step):
    try:
        wait_until(world.bundle_task_complete_rolebuilder, args=(world.bundle_id,), timeout=2000,
                   error_text='Bundletask %s is not completed' % world.bundle_id)
    except BaseException as e:
        rolebuilder_server = world.rolebuilder_server
        test_name = step.scenario.described_at.file.split('/')[-1].split('.')[0]
        path = os.path.realpath(os.path.join(CONF.main.log_path, 'scalarizr',
                                             test_name,
                                             world.test_start_time.strftime('%m%d-%H:%M'),
                                             step.scenario.name.replace('/', '-'),
                                             rolebuilder_server.id + '-role-builder.log.gz'))
        LOG.debug('Path to save log: %s' % path)
        if not os.path.exists(os.path.dirname(path)):
            os.makedirs(os.path.dirname(path), 0755)
        rolebuilder_server.get_logs('../role-builder.log', path, compress=True)
        rolebuilder_server.terminate()
        raise e

def assert_check_resolv(step, domain_as, serv_as, timeout=1800):
    domain = getattr(world, domain_as)
    server = getattr(world, serv_as)
    domain_ip = wait_until(world.check_resolving,
                           args=(domain.name,),
                           timeout=timeout,
                           error_text='Domain: {0} not resolve'.format(domain.name))
    assert domain_ip == server.public_ip, 'Domain IP {0} != server IP {1}'.format(
        domain_ip,
        server.public_ip)