[ceph.git] / ceph / src / test / rgw / rgw_multi / tests_es.py

import json
import logging

import boto
import boto.s3.connection

import datetime
import dateutil

from nose.tools import eq_ as eq
from six.moves import range

from .multisite import *
from .tests import *
from .zone_es import *

log = logging.getLogger(__name__)


def check_es_configured():
    realm = get_realm()
    zonegroup = realm.master_zonegroup()

    es_zones = zonegroup.zones_by_type.get("elasticsearch")
    if not es_zones:
        raise SkipTest("Requires at least one ES zone")

def is_es_zone(zone_conn):
    if not zone_conn:
        return False

    return zone_conn.zone.tier_type() == "elasticsearch"

def verify_search(bucket_name, src_keys, result_keys, f):
    check_keys = []
    for k in src_keys:
        if bucket_name:
            if bucket_name != k.bucket.name:
                continue
        if f(k):
            check_keys.append(k)
    check_keys.sort(key = lambda l: (l.bucket.name, l.name, l.version_id))

    log.debug('check keys:' + dump_json(check_keys))
    log.debug('result keys:' + dump_json(result_keys))

    for k1, k2 in zip_longest(check_keys, result_keys):
        assert k1
        assert k2
        check_object_eq(k1, k2)

def do_check_mdsearch(conn, bucket, src_keys, req_str, src_filter):
    if bucket:
        bucket_name = bucket.name
    else:
        bucket_name = ''
    req = MDSearch(conn, bucket_name, req_str)
    result_keys = req.search(sort_key = lambda k: (k.bucket.name, k.name, k.version_id))
    verify_search(bucket_name, src_keys, result_keys, src_filter)

def init_env(create_obj, num_keys = 5, buckets_per_zone = 1, bucket_init_cb = None):
    check_es_configured()

    realm = get_realm()
    zonegroup = realm.master_zonegroup()
    zonegroup_conns = ZonegroupConns(zonegroup)
    buckets, zone_bucket = create_bucket_per_zone(zonegroup_conns, buckets_per_zone = buckets_per_zone)

    if bucket_init_cb:
        for zone_conn, bucket in zone_bucket:
            bucket_init_cb(zone_conn, bucket)

    src_keys = []

    owner = None

    obj_prefix=''.join(random.choice(string.ascii_lowercase) for _ in range(6))

    # don't wait for meta sync just yet
    for zone, bucket in zone_bucket:
        for count in range(num_keys):
            objname = obj_prefix + str(count)
            k = new_key(zone, bucket.name, objname)
            # k.set_contents_from_string(content + 'x' * count)
            if not create_obj:
                continue

            create_obj(k, count)

            if not owner:
                for list_key in bucket.list_versions():
                    owner = list_key.owner
                    break

            k = bucket.get_key(k.name, version_id = k.version_id)
            k.owner = owner # owner is not set when doing get_key()

            src_keys.append(k)

    zonegroup_meta_checkpoint(zonegroup)

    sources = []
    targets = []
    for target_conn in zonegroup_conns.zones:
        if not is_es_zone(target_conn):
            sources.append(target_conn)
            continue

        targets.append(target_conn)

    buckets = []
    # make sure all targets are synced
    for source_conn, bucket in zone_bucket:
        buckets.append(bucket)
        for target_conn in targets:
            zone_bucket_checkpoint(target_conn.zone, source_conn.zone, bucket.name)

    return targets, sources, buckets, src_keys

def test_es_object_search():
    min_size = 10
    content = 'a' * min_size

    def create_obj(k, i):
        k.set_contents_from_string(content + 'x' * i)

    targets, _, buckets, src_keys = init_env(create_obj, num_keys = 5, buckets_per_zone = 2)

    for target_conn in targets:

        # bucket checks
        for bucket in buckets:
            # check name
            do_check_mdsearch(target_conn.conn, None, src_keys , 'bucket == ' + bucket.name, lambda k: k.bucket.name == bucket.name)
            do_check_mdsearch(target_conn.conn, bucket, src_keys , 'bucket == ' + bucket.name, lambda k: k.bucket.name == bucket.name)

        # check on all buckets
        for key in src_keys:
            # limiting to checking specific key name, otherwise could get results from
            # other runs / tests
            do_check_mdsearch(target_conn.conn, None, src_keys , 'name == ' + key.name, lambda k: k.name == key.name)

        # check on specific bucket
        for bucket in buckets:
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name < ' + key.name, lambda k: k.name < key.name)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name <= ' + key.name, lambda k: k.name <= key.name)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name == ' + key.name, lambda k: k.name == key.name)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name >= ' + key.name, lambda k: k.name >= key.name)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name > ' + key.name, lambda k: k.name > key.name)

            do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name == ' + src_keys[0].name + ' or name >= ' + src_keys[2].name,
                              lambda k: k.name == src_keys[0].name or k.name >= src_keys[2].name)

            # check etag
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'etag < ' + key.etag[1:-1], lambda k: k.etag < key.etag)
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'etag == ' + key.etag[1:-1], lambda k: k.etag == key.etag)
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'etag > ' + key.etag[1:-1], lambda k: k.etag > key.etag)

            # check size
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size < ' + str(key.size), lambda k: k.size < key.size)
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size <= ' + str(key.size), lambda k: k.size <= key.size)
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size == ' + str(key.size), lambda k: k.size == key.size)
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size >= ' + str(key.size), lambda k: k.size >= key.size)
            for key in src_keys:
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size > ' + str(key.size), lambda k: k.size > key.size)

def date_from_str(s):
    return dateutil.parser.parse(s)

def test_es_object_search_custom():
    min_size = 10
    content = 'a' * min_size

    def bucket_init(zone_conn, bucket):
        req = MDSearchConfig(zone_conn.conn, bucket.name)
        req.set_config('x-amz-meta-foo-str; string, x-amz-meta-foo-int; int, x-amz-meta-foo-date; date')

    def create_obj(k, i):
        date = datetime.datetime.now() + datetime.timedelta(seconds=1) * i
        date_str = date.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
        k.set_contents_from_string(content + 'x' * i, headers = { 'X-Amz-Meta-Foo-Str': str(i * 5),
                                                                  'X-Amz-Meta-Foo-Int': str(i * 5),
                                                                  'X-Amz-Meta-Foo-Date': date_str})

    targets, _, buckets, src_keys = init_env(create_obj, num_keys = 5, buckets_per_zone = 1, bucket_init_cb = bucket_init)


    for target_conn in targets:

        # bucket checks
        for bucket in buckets:
            str_vals = []
            for key in src_keys:
                # check string values
                val = key.get_metadata('foo-str')
                str_vals.append(val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str < ' + val, lambda k: k.get_metadata('foo-str') < val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str <= ' + val, lambda k: k.get_metadata('foo-str') <= val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str == ' + val, lambda k: k.get_metadata('foo-str') == val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str >= ' + val, lambda k: k.get_metadata('foo-str') >= val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str > ' + val, lambda k: k.get_metadata('foo-str') > val)

                # check int values
                sval = key.get_metadata('foo-int')
                val = int(sval)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int < ' + sval, lambda k: int(k.get_metadata('foo-int')) < val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int <= ' + sval, lambda k: int(k.get_metadata('foo-int')) <= val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int == ' + sval, lambda k: int(k.get_metadata('foo-int')) == val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int >= ' + sval, lambda k: int(k.get_metadata('foo-int')) >= val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int > ' + sval, lambda k: int(k.get_metadata('foo-int')) > val)

                # check int values
                sval = key.get_metadata('foo-date')
                val = date_from_str(sval)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date < ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) < val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date <= ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) <= val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date == ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) == val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date >= ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) >= val)
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date > ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) > val)

            # 'or' query
            for i in range(len(src_keys) // 2):
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str <= ' + str_vals[i] + ' or x-amz-meta-foo-str >= ' + str_vals[-i],
                        lambda k: k.get_metadata('foo-str') <= str_vals[i] or k.get_metadata('foo-str') >= str_vals[-i] )

            # 'and' query
            for i in range(len(src_keys) // 2):
                do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str >= ' + str_vals[i] + ' and x-amz-meta-foo-str <= ' + str_vals[i + 1],
                        lambda k: k.get_metadata('foo-str') >= str_vals[i] and k.get_metadata('foo-str') <= str_vals[i + 1] )
            # more complicated query
            for i in range(len(src_keys) // 2):
                do_check_mdsearch(target_conn.conn, None, src_keys , 'bucket == ' + bucket.name + ' and x-amz-meta-foo-str >= ' + str_vals[i] +
                                                                     ' and (x-amz-meta-foo-str <= ' + str_vals[i + 1] + ')',
                        lambda k: k.bucket.name == bucket.name and (k.get_metadata('foo-str') >= str_vals[i] and
                                                                    k.get_metadata('foo-str') <= str_vals[i + 1]) )

def test_es_bucket_conf():
    min_size = 0

    def bucket_init(zone_conn, bucket):
        req = MDSearchConfig(zone_conn.conn, bucket.name)
        req.set_config('x-amz-meta-foo-str; string, x-amz-meta-foo-int; int, x-amz-meta-foo-date; date')

    targets, sources, buckets, _ = init_env(None, num_keys = 5, buckets_per_zone = 1, bucket_init_cb = bucket_init)

    for source_conn in sources:
        for bucket in buckets:
            req = MDSearchConfig(source_conn.conn, bucket.name)
            conf = req.get_config()

            d = {}

            for entry in conf:
              d[entry['Key']] = entry['Type']

            eq(len(d), 3)
            eq(d['x-amz-meta-foo-str'], 'str')
            eq(d['x-amz-meta-foo-int'], 'int')
            eq(d['x-amz-meta-foo-date'], 'date')

            req.del_config()

            conf = req.get_config()

            eq(len(conf), 0)

        break # no need to iterate over all zones
Commit	Line	Data
31f18b77 FG	1	import json
	2	import logging
	3
	4	import boto
	5	import boto.s3.connection
	6
	7	import datetime
	8	import dateutil
	9
	10	from nose.tools import eq_ as eq
e306af50	11	from six.moves import range
31f18b77	12
e306af50 TL	13	from .multisite import *
	14	from .tests import *
	15	from .zone_es import *
31f18b77 FG	16
	17	log = logging.getLogger(__name__)
	18
	19
	20	def check_es_configured():
	21	realm = get_realm()
	22	zonegroup = realm.master_zonegroup()
	23
	24	es_zones = zonegroup.zones_by_type.get("elasticsearch")
	25	if not es_zones:
	26	raise SkipTest("Requires at least one ES zone")
	27
	28	def is_es_zone(zone_conn):
	29	if not zone_conn:
	30	return False
	31
	32	return zone_conn.zone.tier_type() == "elasticsearch"
	33
	34	def verify_search(bucket_name, src_keys, result_keys, f):
	35	check_keys = []
	36	for k in src_keys:
	37	if bucket_name:
	38	if bucket_name != k.bucket.name:
	39	continue
	40	if f(k):
	41	check_keys.append(k)
	42	check_keys.sort(key = lambda l: (l.bucket.name, l.name, l.version_id))
	43
	44	log.debug('check keys:' + dump_json(check_keys))
	45	log.debug('result keys:' + dump_json(result_keys))
	46
	47	for k1, k2 in zip_longest(check_keys, result_keys):
	48	assert k1
	49	assert k2
	50	check_object_eq(k1, k2)
	51
	52	def do_check_mdsearch(conn, bucket, src_keys, req_str, src_filter):
	53	if bucket:
	54	bucket_name = bucket.name
	55	else:
	56	bucket_name = ''
	57	req = MDSearch(conn, bucket_name, req_str)
	58	result_keys = req.search(sort_key = lambda k: (k.bucket.name, k.name, k.version_id))
	59	verify_search(bucket_name, src_keys, result_keys, src_filter)
	60
	61	def init_env(create_obj, num_keys = 5, buckets_per_zone = 1, bucket_init_cb = None):
	62	check_es_configured()
	63
	64	realm = get_realm()
	65	zonegroup = realm.master_zonegroup()
	66	zonegroup_conns = ZonegroupConns(zonegroup)
	67	buckets, zone_bucket = create_bucket_per_zone(zonegroup_conns, buckets_per_zone = buckets_per_zone)
	68
	69	if bucket_init_cb:
	70	for zone_conn, bucket in zone_bucket:
	71	bucket_init_cb(zone_conn, bucket)
	72
	73	src_keys = []
	74
	75	owner = None
	76
	77	obj_prefix=''.join(random.choice(string.ascii_lowercase) for _ in range(6))
	78
	79	# don't wait for meta sync just yet
80	for zone, bucket in zone_bucket:
e306af50	81	for count in range(num_keys):
31f18b77 FG	82	objname = obj_prefix + str(count)
	83	k = new_key(zone, bucket.name, objname)
	84	# k.set_contents_from_string(content + 'x' * count)
	85	if not create_obj:
	86	continue
	87
	88	create_obj(k, count)
	89
	90	if not owner:
	91	for list_key in bucket.list_versions():
	92	owner = list_key.owner
	93	break
	94
	95	k = bucket.get_key(k.name, version_id = k.version_id)
	96	k.owner = owner # owner is not set when doing get_key()
	97
	98	src_keys.append(k)
	99
	100	zonegroup_meta_checkpoint(zonegroup)
	101
	102	sources = []
	103	targets = []
	104	for target_conn in zonegroup_conns.zones:
	105	if not is_es_zone(target_conn):
	106	sources.append(target_conn)
	107	continue
	108
	109	targets.append(target_conn)
	110
	111	buckets = []
	112	# make sure all targets are synced
	113	for source_conn, bucket in zone_bucket:
	114	buckets.append(bucket)
	115	for target_conn in targets:
	116	zone_bucket_checkpoint(target_conn.zone, source_conn.zone, bucket.name)
	117
	118	return targets, sources, buckets, src_keys
	119
	120	def test_es_object_search():
	121	min_size = 10
	122	content = 'a' * min_size
	123
	124	def create_obj(k, i):
	125	k.set_contents_from_string(content + 'x' * i)
	126
	127	targets, _, buckets, src_keys = init_env(create_obj, num_keys = 5, buckets_per_zone = 2)
	128
	129	for target_conn in targets:
	130
	131	# bucket checks
	132	for bucket in buckets:
	133	# check name
	134	do_check_mdsearch(target_conn.conn, None, src_keys , 'bucket == ' + bucket.name, lambda k: k.bucket.name == bucket.name)
	135	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'bucket == ' + bucket.name, lambda k: k.bucket.name == bucket.name)
	136
	137	# check on all buckets
	138	for key in src_keys:
	139	# limiting to checking specific key name, otherwise could get results from
	140	# other runs / tests
	141	do_check_mdsearch(target_conn.conn, None, src_keys , 'name == ' + key.name, lambda k: k.name == key.name)
	142
	143	# check on specific bucket
	144	for bucket in buckets:
	145	for key in src_keys:
146	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name < ' + key.name, lambda k: k.name < key.name)
147	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name <= ' + key.name, lambda k: k.name <= key.name)
148	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name == ' + key.name, lambda k: k.name == key.name)
149	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name >= ' + key.name, lambda k: k.name >= key.name)
150	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name > ' + key.name, lambda k: k.name > key.name)
151
152	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'name == ' + src_keys[0].name + ' or name >= ' + src_keys[2].name,
153	lambda k: k.name == src_keys[0].name or k.name >= src_keys[2].name)
154
155	# check etag
156	for key in src_keys:
157	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'etag < ' + key.etag[1:-1], lambda k: k.etag < key.etag)
158	for key in src_keys:
159	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'etag == ' + key.etag[1:-1], lambda k: k.etag == key.etag)
160	for key in src_keys:
161	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'etag > ' + key.etag[1:-1], lambda k: k.etag > key.etag)
162
163	# check size
164	for key in src_keys:
165	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size < ' + str(key.size), lambda k: k.size < key.size)
166	for key in src_keys:
167	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size <= ' + str(key.size), lambda k: k.size <= key.size)
168	for key in src_keys:
169	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size == ' + str(key.size), lambda k: k.size == key.size)
170	for key in src_keys:
171	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size >= ' + str(key.size), lambda k: k.size >= key.size)
172	for key in src_keys:
173	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'size > ' + str(key.size), lambda k: k.size > key.size)
174
175	def date_from_str(s):
176	return dateutil.parser.parse(s)
177
178	def test_es_object_search_custom():
179	min_size = 10
180	content = 'a' * min_size
181
182	def bucket_init(zone_conn, bucket):
183	req = MDSearchConfig(zone_conn.conn, bucket.name)
184	req.set_config('x-amz-meta-foo-str; string, x-amz-meta-foo-int; int, x-amz-meta-foo-date; date')
185
186	def create_obj(k, i):
187	date = datetime.datetime.now() + datetime.timedelta(seconds=1) * i
188	date_str = date.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
189	k.set_contents_from_string(content + 'x' * i, headers = { 'X-Amz-Meta-Foo-Str': str(i * 5),
190	'X-Amz-Meta-Foo-Int': str(i * 5),
191	'X-Amz-Meta-Foo-Date': date_str})
192
193	targets, _, buckets, src_keys = init_env(create_obj, num_keys = 5, buckets_per_zone = 1, bucket_init_cb = bucket_init)
194
195
196	for target_conn in targets:
197
198	# bucket checks
199	for bucket in buckets:
200	str_vals = []
201	for key in src_keys:
202	# check string values
203	val = key.get_metadata('foo-str')
204	str_vals.append(val)
205	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str < ' + val, lambda k: k.get_metadata('foo-str') < val)
206	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str <= ' + val, lambda k: k.get_metadata('foo-str') <= val)
207	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str == ' + val, lambda k: k.get_metadata('foo-str') == val)
208	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str >= ' + val, lambda k: k.get_metadata('foo-str') >= val)
209	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str > ' + val, lambda k: k.get_metadata('foo-str') > val)
210
211	# check int values
212	sval = key.get_metadata('foo-int')
213	val = int(sval)
214	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int < ' + sval, lambda k: int(k.get_metadata('foo-int')) < val)
215	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int <= ' + sval, lambda k: int(k.get_metadata('foo-int')) <= val)
216	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int == ' + sval, lambda k: int(k.get_metadata('foo-int')) == val)
217	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int >= ' + sval, lambda k: int(k.get_metadata('foo-int')) >= val)
218	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-int > ' + sval, lambda k: int(k.get_metadata('foo-int')) > val)
219
220	# check int values
221	sval = key.get_metadata('foo-date')
222	val = date_from_str(sval)
223	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date < ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) < val)
224	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date <= ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) <= val)
225	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date == ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) == val)
226	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date >= ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) >= val)
227	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-date > ' + sval, lambda k: date_from_str(k.get_metadata('foo-date')) > val)
228
229	# 'or' query
e306af50	230	for i in range(len(src_keys) // 2):
31f18b77 FG	231	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str <= ' + str_vals[i] + ' or x-amz-meta-foo-str >= ' + str_vals[-i],
	232	lambda k: k.get_metadata('foo-str') <= str_vals[i] or k.get_metadata('foo-str') >= str_vals[-i] )
	233
	234	# 'and' query
e306af50	235	for i in range(len(src_keys) // 2):
31f18b77 FG	236	do_check_mdsearch(target_conn.conn, bucket, src_keys , 'x-amz-meta-foo-str >= ' + str_vals[i] + ' and x-amz-meta-foo-str <= ' + str_vals[i + 1],
	237	lambda k: k.get_metadata('foo-str') >= str_vals[i] and k.get_metadata('foo-str') <= str_vals[i + 1] )
	238	# more complicated query
e306af50	239	for i in range(len(src_keys) // 2):
31f18b77 FG	240	do_check_mdsearch(target_conn.conn, None, src_keys , 'bucket == ' + bucket.name + ' and x-amz-meta-foo-str >= ' + str_vals[i] +
	241	' and (x-amz-meta-foo-str <= ' + str_vals[i + 1] + ')',
	242	lambda k: k.bucket.name == bucket.name and (k.get_metadata('foo-str') >= str_vals[i] and
	243	k.get_metadata('foo-str') <= str_vals[i + 1]) )
	244
	245	def test_es_bucket_conf():
	246	min_size = 0
	247
	248	def bucket_init(zone_conn, bucket):
	249	req = MDSearchConfig(zone_conn.conn, bucket.name)
	250	req.set_config('x-amz-meta-foo-str; string, x-amz-meta-foo-int; int, x-amz-meta-foo-date; date')
	251
	252	targets, sources, buckets, _ = init_env(None, num_keys = 5, buckets_per_zone = 1, bucket_init_cb = bucket_init)
	253
	254	for source_conn in sources:
	255	for bucket in buckets:
	256	req = MDSearchConfig(source_conn.conn, bucket.name)
	257	conf = req.get_config()
	258
	259	d = {}
	260
	261	for entry in conf:
	262	d[entry['Key']] = entry['Type']
	263
	264	eq(len(d), 3)
	265	eq(d['x-amz-meta-foo-str'], 'str')
	266	eq(d['x-amz-meta-foo-int'], 'int')
	267	eq(d['x-amz-meta-foo-date'], 'date')
	268
	269	req.del_config()
	270
	271	conf = req.get_config()
	272
	273	eq(len(conf), 0)
	274
	275	break # no need to iterate over all zones