← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ceph/quantal

« back to all changes in this revision

Viewing changes to src/rgw/rgw_rest_s3.cc

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2012-07-16 09:56:24 UTC
  • mfrom: (0.3.11)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: package-import@ubuntu.com-20120716095624-azr2w4hbhei1rxmx
Tags: upstream-0.48
Import upstream version 0.48

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rgw/rgw_rest_s3.cc
34
34
void dump_bucket(struct req_state *s, RGWBucketEnt& obj)
35
35
{
36
36
  s->formatter->open_object_section("Bucket");
37
 
  s->formatter->dump_format("Name", obj.bucket.name.c_str());
 
37
  s->formatter->dump_string("Name", obj.bucket.name);
38
38
  dump_time(s, "CreationDate", &obj.mtime);
39
39
  s->formatter->close_section();
40
40
}
147
147
 
148
148
  s->formatter->open_object_section_in_ns("ListBucketResult",
149
149
                                          "http://s3.amazonaws.com/doc/2006-03-01/");
150
 
  s->formatter->dump_format("Name", s->bucket_name);
 
150
  s->formatter->dump_string("Name", s->bucket_name);
151
151
  if (!prefix.empty())
152
 
    s->formatter->dump_format("Prefix", prefix.c_str());
153
 
  s->formatter->dump_format("Marker", marker.c_str());
 
152
    s->formatter->dump_string("Prefix", prefix);
 
153
  s->formatter->dump_string("Marker", marker);
154
154
  s->formatter->dump_int("MaxKeys", max);
155
155
  if (!delimiter.empty())
156
 
    s->formatter->dump_format("Delimiter", delimiter.c_str());
 
156
    s->formatter->dump_string("Delimiter", delimiter);
157
157
 
158
 
  s->formatter->dump_format("IsTruncated", (max && is_truncated ? "true" : "false"));
 
158
  s->formatter->dump_string("IsTruncated", (max && is_truncated ? "true" : "false"));
159
159
 
160
160
  if (ret >= 0) {
161
161
    vector<RGWObjEnt>::iterator iter;
162
162
    for (iter = objs.begin(); iter != objs.end(); ++iter) {
163
163
      s->formatter->open_array_section("Contents");
164
 
      s->formatter->dump_string("Key", iter->name.c_str());
 
164
      s->formatter->dump_string("Key", iter->name);
165
165
      dump_time(s, "LastModified", &iter->mtime);
166
166
      s->formatter->dump_format("ETag", "\"%s\"", iter->etag.c_str());
167
167
      s->formatter->dump_int("Size", iter->size);
168
 
      s->formatter->dump_format("StorageClass", "STANDARD");
 
168
      s->formatter->dump_string("StorageClass", "STANDARD");
169
169
      dump_owner(s, iter->owner, iter->owner_display_name);
170
170
      s->formatter->close_section();
171
171
    }
173
173
      map<string, bool>::iterator pref_iter;
174
174
      for (pref_iter = common_prefixes.begin(); pref_iter != common_prefixes.end(); ++pref_iter) {
175
175
        s->formatter->open_array_section("CommonPrefixes");
176
 
        s->formatter->dump_format("Prefix", pref_iter->first.c_str());
 
176
        s->formatter->dump_string("Prefix", pref_iter->first);
177
177
        s->formatter->close_section();
178
178
      }
179
179
    }
309
309
  dest_bucket_name = s->bucket.name;
310
310
  dest_object = s->object_str;
311
311
 
 
312
  const char *md_directive = s->env->get("HTTP_X_AMZ_METADATA_DIRECTIVE");
 
313
  if (md_directive) {
 
314
    if (strcasecmp(md_directive, "COPY") == 0) {
 
315
      replace_attrs = false;
 
316
    } else if (strcasecmp(md_directive, "REPLACE") == 0) {
 
317
      replace_attrs = true;
 
318
    } else {
 
319
      return -EINVAL;
 
320
    }
 
321
  }
 
322
 
 
323
  if ((dest_bucket_name.compare(src_bucket_name) == 0) &&
 
324
      (dest_object.compare(src_object) == 0) &&
 
325
      !replace_attrs) {
 
326
    /* can only copy object into itself if replacing attrs */
 
327
    return -ERR_INVALID_REQUEST;
 
328
  }
312
329
  return 0;
313
330
}
314
331
 
327
344
      bufferlist& bl = iter->second;
328
345
      if (bl.length()) {
329
346
        char *etag = bl.c_str();
330
 
        s->formatter->dump_format("ETag", etag);
 
347
        s->formatter->dump_string("ETag", etag);
331
348
      }
332
349
    }
333
350
    s->formatter->close_section();
388
405
    dump_start(s);
389
406
    s->formatter->open_object_section_in_ns("InitiateMultipartUploadResult",
390
407
                  "http://s3.amazonaws.com/doc/2006-03-01/");
391
 
    s->formatter->dump_format("Bucket", s->bucket_name);
392
 
    s->formatter->dump_format("Key", s->object);
393
 
    s->formatter->dump_format("UploadId", upload_id.c_str());
 
408
    s->formatter->dump_string("Bucket", s->bucket_name);
 
409
    s->formatter->dump_string("Key", s->object);
 
410
    s->formatter->dump_string("UploadId", upload_id);
394
411
    s->formatter->close_section();
395
412
    flush_formatter_to_req_state(s, s->formatter);
396
413
  }
408
425
                          "http://s3.amazonaws.com/doc/2006-03-01/");
409
426
    if (g_conf->rgw_dns_name.length())
410
427
      s->formatter->dump_format("Location", "%s.%s", s->bucket_name, g_conf->rgw_dns_name.c_str());
411
 
    s->formatter->dump_format("Bucket", s->bucket_name);
412
 
    s->formatter->dump_format("Key", s->object);
413
 
    s->formatter->dump_format("ETag", etag.c_str());
 
428
    s->formatter->dump_string("Bucket", s->bucket_name);
 
429
    s->formatter->dump_string("Key", s->object);
 
430
    s->formatter->dump_string("ETag", etag);
414
431
    s->formatter->close_section();
415
432
    flush_formatter_to_req_state(s, s->formatter);
416
433
  }
445
462
    for (i = 0, test_iter = iter; test_iter != parts.end() && i < max_parts; ++test_iter, ++i) {
446
463
      cur_max = test_iter->first;
447
464
    }
448
 
    s->formatter->dump_format("Bucket", s->bucket_name);
449
 
    s->formatter->dump_format("Key", s->object);
450
 
    s->formatter->dump_format("UploadId", upload_id.c_str());
451
 
    s->formatter->dump_format("StorageClass", "STANDARD");
452
 
    s->formatter->dump_format("PartNumberMarker", "%d", marker);
453
 
    s->formatter->dump_format("NextPartNumberMarker", "%d", cur_max + 1);
454
 
    s->formatter->dump_format("MaxParts", "%d", max_parts);
455
 
    s->formatter->dump_format("IsTruncated", "%s", (test_iter == parts.end() ? "false" : "true"));
 
465
    s->formatter->dump_string("Bucket", s->bucket_name);
 
466
    s->formatter->dump_string("Key", s->object);
 
467
    s->formatter->dump_string("UploadId", upload_id);
 
468
    s->formatter->dump_string("StorageClass", "STANDARD");
 
469
    s->formatter->dump_int("PartNumberMarker", marker);
 
470
    s->formatter->dump_int("NextPartNumberMarker", cur_max + 1);
 
471
    s->formatter->dump_int("MaxParts", max_parts);
 
472
    s->formatter->dump_string("IsTruncated", (test_iter == parts.end() ? "false" : "true"));
456
473
 
457
474
    ACLOwner& owner = policy.get_owner();
458
475
    dump_owner(s, owner.get_id(), owner.get_display_name());
468
485
      s->formatter->open_object_section("Part");
469
486
 
470
487
      if (strftime(buf, sizeof(buf), "%Y-%m-%dT%T.000Z", &tmp) > 0) {
471
 
        s->formatter->dump_format("LastModified", buf);
 
488
        s->formatter->dump_string("LastModified", buf);
472
489
      }
473
490
 
474
491
      s->formatter->dump_unsigned("PartNumber", info.num);
475
 
      s->formatter->dump_format("ETag", "%s", info.etag.c_str());
 
492
      s->formatter->dump_string("ETag", info.etag);
476
493
      s->formatter->dump_unsigned("Size", info.size);
477
494
      s->formatter->close_section();
478
495
    }
493
510
    return;
494
511
 
495
512
  s->formatter->open_object_section("ListMultipartUploadsResult");
496
 
  s->formatter->dump_format("Bucket", s->bucket_name);
 
513
  s->formatter->dump_string("Bucket", s->bucket_name);
497
514
  if (!prefix.empty())
498
 
    s->formatter->dump_format("ListMultipartUploadsResult.Prefix", prefix.c_str());
 
515
    s->formatter->dump_string("ListMultipartUploadsResult.Prefix", prefix);
499
516
  string& key_marker = marker.get_key();
500
517
  if (!key_marker.empty())
501
 
    s->formatter->dump_format("KeyMarker", key_marker.c_str());
 
518
    s->formatter->dump_string("KeyMarker", key_marker);
502
519
  string& upload_id_marker = marker.get_upload_id();
503
520
  if (!upload_id_marker.empty())
504
 
    s->formatter->dump_format("UploadIdMarker", upload_id_marker.c_str());
 
521
    s->formatter->dump_string("UploadIdMarker", upload_id_marker);
505
522
  string next_key = next_marker.mp.get_key();
506
523
  if (!next_key.empty())
507
 
    s->formatter->dump_format("NextKeyMarker", next_key.c_str());
 
524
    s->formatter->dump_string("NextKeyMarker", next_key);
508
525
  string next_upload_id = next_marker.mp.get_upload_id();
509
526
  if (!next_upload_id.empty())
510
 
    s->formatter->dump_format("NextUploadIdMarker", next_upload_id.c_str());
511
 
  s->formatter->dump_format("MaxUploads", "%d", max_uploads);
 
527
    s->formatter->dump_string("NextUploadIdMarker", next_upload_id);
 
528
  s->formatter->dump_int("MaxUploads", max_uploads);
512
529
  if (!delimiter.empty())
513
 
    s->formatter->dump_format("Delimiter", delimiter.c_str());
514
 
  s->formatter->dump_format("IsTruncated", (is_truncated ? "true" : "false"));
 
530
    s->formatter->dump_string("Delimiter", delimiter);
 
531
  s->formatter->dump_string("IsTruncated", (is_truncated ? "true" : "false"));
515
532
 
516
533
  if (ret >= 0) {
517
534
    vector<RGWMultipartUploadEntry>::iterator iter;
518
535
    for (iter = uploads.begin(); iter != uploads.end(); ++iter) {
519
536
      RGWMPObj& mp = iter->mp;
520
537
      s->formatter->open_array_section("Upload");
521
 
      s->formatter->dump_format("Key", mp.get_key().c_str());
522
 
      s->formatter->dump_format("UploadId", mp.get_upload_id().c_str());
 
538
      s->formatter->dump_string("Key", mp.get_key());
 
539
      s->formatter->dump_string("UploadId", mp.get_upload_id());
523
540
      dump_owner(s, s->user.user_id, s->user.display_name, "Initiator");
524
541
      dump_owner(s, s->user.user_id, s->user.display_name);
525
 
      s->formatter->dump_format("StorageClass", "STANDARD");
 
542
      s->formatter->dump_string("StorageClass", "STANDARD");
526
543
      dump_time(s, "Initiated", &iter->obj.mtime);
527
544
      s->formatter->close_section();
528
545
    }
530
547
      s->formatter->open_array_section("CommonPrefixes");
531
548
      map<string, bool>::iterator pref_iter;
532
549
      for (pref_iter = common_prefixes.begin(); pref_iter != common_prefixes.end(); ++pref_iter) {
533
 
        s->formatter->dump_format("CommonPrefixes.Prefix", pref_iter->first.c_str());
 
550
        s->formatter->dump_string("CommonPrefixes.Prefix", pref_iter->first);
534
551
      }
535
552
      s->formatter->close_section();
536
553
    }