ceph/qa/tasks/radosgw_admin.py

   1 """
   2 Rgw admin testing against a running instance
   3 """
   4 # The test cases in this file have been annotated for inventory.
   5 # To extract the inventory (in csv format) use the command:
   6 #
   7 #   grep '^ *# TESTCASE' | sed 's/^ *# TESTCASE //'
   8 #
   9
  10 import copy
  11 import json
  12 import logging
  13 import time
  14 import datetime
  15
  16 from cStringIO import StringIO
  17
  18 import boto.exception
  19 import boto.s3.connection
  20 import boto.s3.acl
  21
  22 import httplib2
  23
  24 import util.rgw as rgw_utils
  25
  26 from util.rgw import rgwadmin, get_user_summary, get_user_successful_ops
  27
  28 log = logging.getLogger(__name__)
  29
  30 def create_presigned_url(conn, method, bucket_name, key_name, expiration):
  31     return conn.generate_url(expires_in=expiration,
  32         method=method,
  33         bucket=bucket_name,
  34         key=key_name,
  35         query_auth=True,
  36     )
  37
  38 def send_raw_http_request(conn, method, bucket_name, key_name, follow_redirects = False):
  39     url = create_presigned_url(conn, method, bucket_name, key_name, 3600)
  40     print url
  41     h = httplib2.Http()
  42     h.follow_redirects = follow_redirects
  43     return h.request(url, method)
  44
  45
  46 def get_acl(key):
  47     """
  48     Helper function to get the xml acl from a key, ensuring that the xml
  49     version tag is removed from the acl response
  50     """
  51     raw_acl = key.get_xml_acl()
  52
  53     def remove_version(string):
  54         return string.split(
  55             '<?xml version="1.0" encoding="UTF-8"?>'
  56         )[-1]
  57
  58     def remove_newlines(string):
  59         return string.strip('\n')
  60
  61     return remove_version(
  62         remove_newlines(raw_acl)
  63     )
  64
  65 def task(ctx, config):
  66     """
  67     Test radosgw-admin functionality against a running rgw instance.
  68     """
  69     global log
  70
  71     assert ctx.rgw.config, \
  72         "radosgw_admin task needs a config passed from the rgw task"
  73     config = ctx.rgw.config
  74     log.debug('config is: %r', config)
  75
  76     clients_from_config = config.keys()
  77
  78     # choose first client as default
  79     client = clients_from_config[0]
  80
  81     # once the client is chosen, pull the host name and  assigned port out of
  82     # the role_endpoints that were assigned by the rgw task
  83     (remote_host, remote_port) = ctx.rgw.role_endpoints[client]
  84
  85     ##
  86     user1='foo'
  87     user2='fud'
  88     subuser1='foo:foo1'
  89     subuser2='foo:foo2'
  90     display_name1='Foo'
  91     display_name2='Fud'
  92     email='foo@foo.com'
  93     email2='bar@bar.com'
  94     access_key='9te6NH5mcdcq0Tc5i8i1'
  95     secret_key='Ny4IOauQoL18Gp2zM7lC1vLmoawgqcYP/YGcWfXu'
  96     access_key2='p5YnriCv1nAtykxBrupQ'
  97     secret_key2='Q8Tk6Q/27hfbFSYdSkPtUqhqx1GgzvpXa4WARozh'
  98     swift_secret1='gpS2G9RREMrnbqlp29PP2D36kgPR1tm72n5fPYfL'
  99     swift_secret2='ri2VJQcKSYATOY6uaDUX7pxgkW+W1YmC6OCxPHwy'
 100
 101     bucket_name='myfoo'
 102     bucket_name2='mybar'
 103
 104     # connect to rgw
 105     connection = boto.s3.connection.S3Connection(
 106         aws_access_key_id=access_key,
 107         aws_secret_access_key=secret_key,
 108         is_secure=False,
 109         port=remote_port,
 110         host=remote_host,
 111         calling_format=boto.s3.connection.OrdinaryCallingFormat(),
 112         )
 113     connection2 = boto.s3.connection.S3Connection(
 114         aws_access_key_id=access_key2,
 115         aws_secret_access_key=secret_key2,
 116         is_secure=False,
 117         port=remote_port,
 118         host=remote_host,
 119         calling_format=boto.s3.connection.OrdinaryCallingFormat(),
 120         )
 121
 122     # legend (test cases can be easily grep-ed out)
 123     # TESTCASE 'testname','object','method','operation','assertion'
 124     # TESTCASE 'info-nosuch','user','info','non-existent user','fails'
 125     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1])
 126     assert err
 127
 128     # TESTCASE 'create-ok','user','create','w/all valid info','succeeds'
 129     (err, out) = rgwadmin(ctx, client, [
 130             'user', 'create',
 131             '--uid', user1,
 132             '--display-name', display_name1,
 133             '--email', email,
 134             '--access-key', access_key,
 135             '--secret', secret_key,
 136             '--max-buckets', '4'
 137             ],
 138             check_status=True)
 139
 140     # TESTCASE 'duplicate email','user','create','existing user email','fails'
 141     (err, out) = rgwadmin(ctx, client, [
 142             'user', 'create',
 143             '--uid', user2,
 144             '--display-name', display_name2,
 145             '--email', email,
 146             ])
 147     assert err
 148
 149     # TESTCASE 'info-existing','user','info','existing user','returns correct info'
 150     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1], check_status=True)
 151     assert out['user_id'] == user1
 152     assert out['email'] == email
 153     assert out['display_name'] == display_name1
 154     assert len(out['keys']) == 1
 155     assert out['keys'][0]['access_key'] == access_key
 156     assert out['keys'][0]['secret_key'] == secret_key
 157     assert not out['suspended']
 158
 159     # TESTCASE 'suspend-ok','user','suspend','active user','succeeds'
 160     (err, out) = rgwadmin(ctx, client, ['user', 'suspend', '--uid', user1],
 161         check_status=True)
 162
 163     # TESTCASE 'suspend-suspended','user','suspend','suspended user','succeeds w/advisory'
 164     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1], check_status=True)
 165     assert out['suspended']
 166
 167     # TESTCASE 're-enable','user','enable','suspended user','succeeds'
 168     (err, out) = rgwadmin(ctx, client, ['user', 'enable', '--uid', user1], check_status=True)
 169
 170     # TESTCASE 'info-re-enabled','user','info','re-enabled user','no longer suspended'
 171     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1], check_status=True)
 172     assert not out['suspended']
 173
 174     # TESTCASE 'add-keys','key','create','w/valid info','succeeds'
 175     (err, out) = rgwadmin(ctx, client, [
 176             'key', 'create', '--uid', user1,
 177             '--access-key', access_key2, '--secret', secret_key2,
 178             ], check_status=True)
 179
 180     # TESTCASE 'info-new-key','user','info','after key addition','returns all keys'
 181     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1],
 182         check_status=True)
 183     assert len(out['keys']) == 2
 184     assert out['keys'][0]['access_key'] == access_key2 or out['keys'][1]['access_key'] == access_key2
 185     assert out['keys'][0]['secret_key'] == secret_key2 or out['keys'][1]['secret_key'] == secret_key2
 186
 187     # TESTCASE 'rm-key','key','rm','newly added key','succeeds, key is removed'
 188     (err, out) = rgwadmin(ctx, client, [
 189             'key', 'rm', '--uid', user1,
 190             '--access-key', access_key2,
 191             ], check_status=True)
 192     assert len(out['keys']) == 1
 193     assert out['keys'][0]['access_key'] == access_key
 194     assert out['keys'][0]['secret_key'] == secret_key
 195
 196     # TESTCASE 'add-swift-key','key','create','swift key','succeeds'
 197     subuser_access = 'full'
 198     subuser_perm = 'full-control'
 199
 200     (err, out) = rgwadmin(ctx, client, [
 201             'subuser', 'create', '--subuser', subuser1,
 202             '--access', subuser_access
 203             ], check_status=True)
 204
 205     # TESTCASE 'add-swift-key','key','create','swift key','succeeds'
 206     (err, out) = rgwadmin(ctx, client, [
 207             'subuser', 'modify', '--subuser', subuser1,
 208             '--secret', swift_secret1,
 209             '--key-type', 'swift',
 210             ], check_status=True)
 211
 212     # TESTCASE 'subuser-perm-mask', 'subuser', 'info', 'test subuser perm mask durability', 'succeeds'
 213     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1])
 214
 215     assert out['subusers'][0]['permissions'] == subuser_perm
 216
 217     # TESTCASE 'info-swift-key','user','info','after key addition','returns all keys'
 218     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1], check_status=True)
 219     assert len(out['swift_keys']) == 1
 220     assert out['swift_keys'][0]['user'] == subuser1
 221     assert out['swift_keys'][0]['secret_key'] == swift_secret1
 222
 223     # TESTCASE 'add-swift-subuser','key','create','swift sub-user key','succeeds'
 224     (err, out) = rgwadmin(ctx, client, [
 225             'subuser', 'create', '--subuser', subuser2,
 226             '--secret', swift_secret2,
 227             '--key-type', 'swift',
 228             ], check_status=True)
 229
 230     # TESTCASE 'info-swift-subuser','user','info','after key addition','returns all sub-users/keys'
 231     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1], check_status=True)
 232     assert len(out['swift_keys']) == 2
 233     assert out['swift_keys'][0]['user'] == subuser2 or out['swift_keys'][1]['user'] == subuser2
 234     assert out['swift_keys'][0]['secret_key'] == swift_secret2 or out['swift_keys'][1]['secret_key'] == swift_secret2
 235
 236     # TESTCASE 'rm-swift-key1','key','rm','subuser','succeeds, one key is removed'
 237     (err, out) = rgwadmin(ctx, client, [
 238             'key', 'rm', '--subuser', subuser1,
 239             '--key-type', 'swift',
 240             ], check_status=True)
 241     assert len(out['swift_keys']) == 1
 242
 243     # TESTCASE 'rm-subuser','subuser','rm','subuser','success, subuser is removed'
 244     (err, out) = rgwadmin(ctx, client, [
 245             'subuser', 'rm', '--subuser', subuser1,
 246             ], check_status=True)
 247     assert len(out['subusers']) == 1
 248
 249     # TESTCASE 'rm-subuser-with-keys','subuser','rm','subuser','succeeds, second subser and key is removed'
 250     (err, out) = rgwadmin(ctx, client, [
 251             'subuser', 'rm', '--subuser', subuser2,
 252             '--key-type', 'swift', '--purge-keys',
 253             ], check_status=True)
 254     assert len(out['swift_keys']) == 0
 255     assert len(out['subusers']) == 0
 256
 257     # TESTCASE 'bucket-stats','bucket','stats','no session/buckets','succeeds, empty list'
 258     (err, out) = rgwadmin(ctx, client, ['bucket', 'stats', '--uid', user1],
 259         check_status=True)
 260     assert len(out) == 0
 261
 262     # TESTCASE 'bucket-stats2','bucket','stats','no buckets','succeeds, empty list'
 263     (err, out) = rgwadmin(ctx, client, ['bucket', 'list', '--uid', user1], check_status=True)
 264     assert len(out) == 0
 265
 266     # create a first bucket
 267     bucket = connection.create_bucket(bucket_name)
 268
 269     # TESTCASE 'bucket-list','bucket','list','one bucket','succeeds, expected list'
 270     (err, out) = rgwadmin(ctx, client, ['bucket', 'list', '--uid', user1], check_status=True)
 271     assert len(out) == 1
 272     assert out[0] == bucket_name
 273
 274     # TESTCASE 'bucket-list-all','bucket','list','all buckets','succeeds, expected list'
 275     (err, out) = rgwadmin(ctx, client, ['bucket', 'list'], check_status=True)
 276     assert len(out) >= 1
 277     assert bucket_name in out;
 278
 279     # TESTCASE 'max-bucket-limit,'bucket','create','4 buckets','5th bucket fails due to max buckets == 4'
 280     bucket2 = connection.create_bucket(bucket_name + '2')
 281     bucket3 = connection.create_bucket(bucket_name + '3')
 282     bucket4 = connection.create_bucket(bucket_name + '4')
 283     # the 5th should fail.
 284     failed = False
 285     try:
 286         connection.create_bucket(bucket_name + '5')
 287     except Exception:
 288         failed = True
 289     assert failed
 290
 291     # delete the buckets
 292     bucket2.delete()
 293     bucket3.delete()
 294     bucket4.delete()
 295
 296     # TESTCASE 'bucket-stats3','bucket','stats','new empty bucket','succeeds, empty list'
 297     (err, out) = rgwadmin(ctx, client, [
 298             'bucket', 'stats', '--bucket', bucket_name], check_status=True)
 299     assert out['owner'] == user1
 300     bucket_id = out['id']
 301
 302     # TESTCASE 'bucket-stats4','bucket','stats','new empty bucket','succeeds, expected bucket ID'
 303     (err, out) = rgwadmin(ctx, client, ['bucket', 'stats', '--uid', user1], check_status=True)
 304     assert len(out) == 1
 305     assert out[0]['id'] == bucket_id    # does it return the same ID twice in a row?
 306
 307     # use some space
 308     key = boto.s3.key.Key(bucket)
 309     key.set_contents_from_string('one')
 310
 311     # TESTCASE 'bucket-stats5','bucket','stats','after creating key','succeeds, lists one non-empty object'
 312     (err, out) = rgwadmin(ctx, client, [
 313             'bucket', 'stats', '--bucket', bucket_name], check_status=True)
 314     assert out['id'] == bucket_id
 315     assert out['usage']['rgw.main']['num_objects'] == 1
 316     assert out['usage']['rgw.main']['size_kb'] > 0
 317
 318     # reclaim it
 319     key.delete()
 320
 321     # TESTCASE 'bucket unlink', 'bucket', 'unlink', 'unlink bucket from user', 'fails', 'access denied error'
 322     (err, out) = rgwadmin(ctx, client,
 323         ['bucket', 'unlink', '--uid', user1, '--bucket', bucket_name],
 324         check_status=True)
 325
 326     # create a second user to link the bucket to
 327     (err, out) = rgwadmin(ctx, client, [
 328             'user', 'create',
 329             '--uid', user2,
 330             '--display-name', display_name2,
 331             '--access-key', access_key2,
 332             '--secret', secret_key2,
 333             '--max-buckets', '1',
 334             ],
 335             check_status=True)
 336
 337     # try creating an object with the first user before the bucket is relinked
 338     denied = False
 339     key = boto.s3.key.Key(bucket)
 340
 341     try:
 342         key.set_contents_from_string('two')
 343     except boto.exception.S3ResponseError:
 344         denied = True
 345
 346     assert not denied
 347
 348     # delete the object
 349     key.delete()
 350
 351     # link the bucket to another user
 352     (err, out) = rgwadmin(ctx, client, ['metadata', 'get', 'bucket:{n}'.format(n=bucket_name)],
 353         check_status=True)
 354
 355     bucket_data = out['data']
 356     assert bucket_data['bucket']['name'] == bucket_name
 357
 358     bucket_id = bucket_data['bucket']['bucket_id']
 359
 360     # link the bucket to another user
 361     (err, out) = rgwadmin(ctx, client, ['bucket', 'link', '--uid', user2, '--bucket', bucket_name, '--bucket-id', bucket_id],
 362         check_status=True)
 363
 364     # try to remove user, should fail (has a linked bucket)
 365     (err, out) = rgwadmin(ctx, client, ['user', 'rm', '--uid', user2])
 366     assert err
 367
 368     # TESTCASE 'bucket unlink', 'bucket', 'unlink', 'unlink bucket from user', 'succeeds, bucket unlinked'
 369     (err, out) = rgwadmin(ctx, client, ['bucket', 'unlink', '--uid', user2, '--bucket', bucket_name],
 370         check_status=True)
 371
 372     # relink the bucket to the first user and delete the second user
 373     (err, out) = rgwadmin(ctx, client,
 374         ['bucket', 'link', '--uid', user1, '--bucket', bucket_name, '--bucket-id', bucket_id],
 375         check_status=True)
 376
 377     (err, out) = rgwadmin(ctx, client, ['user', 'rm', '--uid', user2],
 378         check_status=True)
 379
 380     # TESTCASE 'object-rm', 'object', 'rm', 'remove object', 'succeeds, object is removed'
 381
 382     # upload an object
 383     object_name = 'four'
 384     key = boto.s3.key.Key(bucket, object_name)
 385     key.set_contents_from_string(object_name)
 386
 387     # now delete it
 388     (err, out) = rgwadmin(ctx, client,
 389         ['object', 'rm', '--bucket', bucket_name, '--object', object_name],
 390         check_status=True)
 391
 392     # TESTCASE 'bucket-stats6','bucket','stats','after deleting key','succeeds, lists one no objects'
 393     (err, out) = rgwadmin(ctx, client, [
 394             'bucket', 'stats', '--bucket', bucket_name],
 395             check_status=True)
 396     assert out['id'] == bucket_id
 397     assert out['usage']['rgw.main']['num_objects'] == 0
 398
 399     # list log objects
 400     # TESTCASE 'log-list','log','list','after activity','succeeds, lists one no objects'
 401     (err, out) = rgwadmin(ctx, client, ['log', 'list'], check_status=True)
 402     assert len(out) > 0
 403
 404     for obj in out:
 405         # TESTCASE 'log-show','log','show','after activity','returns expected info'
 406         if obj[:4] == 'meta' or obj[:4] == 'data' or obj[:18] == 'obj_delete_at_hint':
 407             continue
 408
 409         (err, rgwlog) = rgwadmin(ctx, client, ['log', 'show', '--object', obj],
 410             check_status=True)
 411         assert len(rgwlog) > 0
 412
 413         # exempt bucket_name2 from checking as it was only used for multi-region tests
 414         assert rgwlog['bucket'].find(bucket_name) == 0 or rgwlog['bucket'].find(bucket_name2) == 0
 415         assert rgwlog['bucket'] != bucket_name or rgwlog['bucket_id'] == bucket_id
 416         assert rgwlog['bucket_owner'] == user1 or rgwlog['bucket'] == bucket_name + '5' or rgwlog['bucket'] == bucket_name2
 417         for entry in rgwlog['log_entries']:
 418             log.debug('checking log entry: ', entry)
 419             assert entry['bucket'] == rgwlog['bucket']
 420             possible_buckets = [bucket_name + '5', bucket_name2]
 421             user = entry['user']
 422             assert user == user1 or user.endswith('system-user') or \
 423                 rgwlog['bucket'] in possible_buckets
 424
 425         # TESTCASE 'log-rm','log','rm','delete log objects','succeeds'
 426         (err, out) = rgwadmin(ctx, client, ['log', 'rm', '--object', obj],
 427             check_status=True)
 428
 429     # TODO: show log by bucket+date
 430
 431     # need to wait for all usage data to get flushed, should take up to 30 seconds
 432     timestamp = time.time()
 433     while time.time() - timestamp <= (20 * 60):      # wait up to 20 minutes
 434         (err, out) = rgwadmin(ctx, client, ['usage', 'show', '--categories', 'delete_obj'])  # last operation we did is delete obj, wait for it to flush
 435         if get_user_successful_ops(out, user1) > 0:
 436             break
 437         time.sleep(1)
 438
 439     assert time.time() - timestamp <= (20 * 60)
 440
 441     # TESTCASE 'usage-show' 'usage' 'show' 'all usage' 'succeeds'
 442     (err, out) = rgwadmin(ctx, client, ['usage', 'show'], check_status=True)
 443     assert len(out['entries']) > 0
 444     assert len(out['summary']) > 0
 445
 446     user_summary = get_user_summary(out, user1)
 447
 448     total = user_summary['total']
 449     assert total['successful_ops'] > 0
 450
 451     # TESTCASE 'usage-show2' 'usage' 'show' 'user usage' 'succeeds'
 452     (err, out) = rgwadmin(ctx, client, ['usage', 'show', '--uid', user1],
 453         check_status=True)
 454     assert len(out['entries']) > 0
 455     assert len(out['summary']) > 0
 456     user_summary = out['summary'][0]
 457     for entry in user_summary['categories']:
 458         assert entry['successful_ops'] > 0
 459     assert user_summary['user'] == user1
 460
 461     # TESTCASE 'usage-show3' 'usage' 'show' 'user usage categories' 'succeeds'
 462     test_categories = ['create_bucket', 'put_obj', 'delete_obj', 'delete_bucket']
 463     for cat in test_categories:
 464         (err, out) = rgwadmin(ctx, client, ['usage', 'show', '--uid', user1, '--categories', cat],
 465             check_status=True)
 466         assert len(out['summary']) > 0
 467         user_summary = out['summary'][0]
 468         assert user_summary['user'] == user1
 469         assert len(user_summary['categories']) == 1
 470         entry = user_summary['categories'][0]
 471         assert entry['category'] == cat
 472         assert entry['successful_ops'] > 0
 473
 474     # the usage flush interval is 30 seconds, wait that much an then some
 475     # to make sure everything has been flushed
 476     time.sleep(35)
 477
 478     # TESTCASE 'usage-trim' 'usage' 'trim' 'user usage' 'succeeds, usage removed'
 479     (err, out) = rgwadmin(ctx, client, ['usage', 'trim', '--uid', user1],
 480         check_status=True)
 481     (err, out) = rgwadmin(ctx, client, ['usage', 'show', '--uid', user1],
 482         check_status=True)
 483     assert len(out['entries']) == 0
 484     assert len(out['summary']) == 0
 485
 486     # TESTCASE 'user-suspend2','user','suspend','existing user','succeeds'
 487     (err, out) = rgwadmin(ctx, client, ['user', 'suspend', '--uid', user1],
 488         check_status=True)
 489
 490     # TESTCASE 'user-suspend3','user','suspend','suspended user','cannot write objects'
 491     try:
 492         key = boto.s3.key.Key(bucket)
 493         key.set_contents_from_string('five')
 494     except boto.exception.S3ResponseError as e:
 495         assert e.status == 403
 496
 497     # TESTCASE 'user-renable2','user','enable','suspended user','succeeds'
 498     (err, out) = rgwadmin(ctx, client, ['user', 'enable', '--uid', user1],
 499         check_status=True)
 500
 501     # TESTCASE 'user-renable3','user','enable','reenabled user','can write objects'
 502     key = boto.s3.key.Key(bucket)
 503     key.set_contents_from_string('six')
 504
 505     # TESTCASE 'gc-list', 'gc', 'list', 'get list of objects ready for garbage collection'
 506
 507     # create an object large enough to be split into multiple parts
 508     test_string = 'foo'*10000000
 509
 510     big_key = boto.s3.key.Key(bucket)
 511     big_key.set_contents_from_string(test_string)
 512
 513     # now delete the head
 514     big_key.delete()
 515
 516     # wait a bit to give the garbage collector time to cycle
 517     time.sleep(15)
 518
 519     (err, out) = rgwadmin(ctx, client, ['gc', 'list'])
 520
 521     assert len(out) > 0
 522
 523     # TESTCASE 'gc-process', 'gc', 'process', 'manually collect garbage'
 524     (err, out) = rgwadmin(ctx, client, ['gc', 'process'], check_status=True)
 525
 526     #confirm
 527     (err, out) = rgwadmin(ctx, client, ['gc', 'list'])
 528
 529     assert len(out) == 0
 530
 531     # TESTCASE 'rm-user-buckets','user','rm','existing user','fails, still has buckets'
 532     (err, out) = rgwadmin(ctx, client, ['user', 'rm', '--uid', user1])
 533     assert err
 534
 535     # delete should fail because ``key`` still exists
 536     try:
 537         bucket.delete()
 538     except boto.exception.S3ResponseError as e:
 539         assert e.status == 409
 540
 541     key.delete()
 542     bucket.delete()
 543
 544     # TESTCASE 'policy', 'bucket', 'policy', 'get bucket policy', 'returns S3 policy'
 545     bucket = connection.create_bucket(bucket_name)
 546
 547     # create an object
 548     key = boto.s3.key.Key(bucket)
 549     key.set_contents_from_string('seven')
 550
 551     # should be private already but guarantee it
 552     key.set_acl('private')
 553
 554     (err, out) = rgwadmin(ctx, client,
 555         ['policy', '--bucket', bucket.name, '--object', key.key],
 556         check_status=True, format='xml')
 557
 558     acl = get_acl(key)
 559
 560     assert acl == out.strip('\n')
 561
 562     # add another grantee by making the object public read
 563     key.set_acl('public-read')
 564
 565     (err, out) = rgwadmin(ctx, client,
 566         ['policy', '--bucket', bucket.name, '--object', key.key],
 567         check_status=True, format='xml')
 568
 569     acl = get_acl(key)
 570
 571     assert acl == out.strip('\n')
 572
 573     # TESTCASE 'rm-bucket', 'bucket', 'rm', 'bucket with objects', 'succeeds'
 574     bucket = connection.create_bucket(bucket_name)
 575     key_name = ['eight', 'nine', 'ten', 'eleven']
 576     for i in range(4):
 577         key = boto.s3.key.Key(bucket)
 578         key.set_contents_from_string(key_name[i])
 579
 580     (err, out) = rgwadmin(ctx, client,
 581         ['bucket', 'rm', '--bucket', bucket_name, '--purge-objects'],
 582         check_status=True)
 583
 584     # TESTCASE 'caps-add', 'caps', 'add', 'add user cap', 'succeeds'
 585     caps='user=read'
 586     (err, out) = rgwadmin(ctx, client, ['caps', 'add', '--uid', user1, '--caps', caps])
 587
 588     assert out['caps'][0]['perm'] == 'read'
 589
 590     # TESTCASE 'caps-rm', 'caps', 'rm', 'remove existing cap from user', 'succeeds'
 591     (err, out) = rgwadmin(ctx, client, ['caps', 'rm', '--uid', user1, '--caps', caps])
 592
 593     assert not out['caps']
 594
 595     # TESTCASE 'rm-user','user','rm','existing user','fails, still has buckets'
 596     bucket = connection.create_bucket(bucket_name)
 597     key = boto.s3.key.Key(bucket)
 598
 599     (err, out) = rgwadmin(ctx, client, ['user', 'rm', '--uid', user1])
 600     assert err
 601
 602     # TESTCASE 'rm-user2', 'user', 'rm', 'user with data', 'succeeds'
 603     bucket = connection.create_bucket(bucket_name)
 604     key = boto.s3.key.Key(bucket)
 605     key.set_contents_from_string('twelve')
 606
 607     (err, out) = rgwadmin(ctx, client,
 608         ['user', 'rm', '--uid', user1, '--purge-data' ],
 609         check_status=True)
 610
 611     # TESTCASE 'rm-user3','user','rm','deleted user','fails'
 612     (err, out) = rgwadmin(ctx, client, ['user', 'info', '--uid', user1])
 613     assert err
 614
 615     # TESTCASE 'zone-info', 'zone', 'get', 'get zone info', 'succeeds, has default placement rule'
 616     #
 617
 618     (err, out) = rgwadmin(ctx, client, ['zone', 'get','--rgw-zone','default'])
 619     orig_placement_pools = len(out['placement_pools'])
 620
 621     # removed this test, it is not correct to assume that zone has default placement, it really
 622     # depends on how we set it up before
 623     #
 624     # assert len(out) > 0
 625     # assert len(out['placement_pools']) == 1
 626
 627     # default_rule = out['placement_pools'][0]
 628     # assert default_rule['key'] == 'default-placement'
 629
 630     rule={'key': 'new-placement', 'val': {'data_pool': '.rgw.buckets.2', 'index_pool': '.rgw.buckets.index.2'}}
 631
 632     out['placement_pools'].append(rule)
 633
 634     (err, out) = rgwadmin(ctx, client, ['zone', 'set'],
 635         stdin=StringIO(json.dumps(out)),
 636         check_status=True)
 637
 638     (err, out) = rgwadmin(ctx, client, ['zone', 'get','--rgw-zone','default'])
 639     assert len(out) > 0
 640     assert len(out['placement_pools']) == orig_placement_pools + 1