ceph/src/rgw/rgw_basic_types.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab ft=cpp
   3
   4 #include <iostream>
   5 #include <sstream>
   6 #include <string>
   7
   8 #include "cls/user/cls_user_types.h"
   9
  10 #include "rgw_basic_types.h"
  11 #include "rgw_bucket.h"
  12 #include "rgw_xml.h"
  13
  14 #include "common/ceph_json.h"
  15 #include "common/Formatter.h"
  16 #include "cls/user/cls_user_types.h"
  17 #include "cls/rgw/cls_rgw_types.h"
  18
  19 using std::ostream;
  20 using std::string;
  21 using std::stringstream;
  22
  23 using namespace std;
  24
  25 void decode_json_obj(rgw_user& val, JSONObj *obj)
  26 {
  27   val.from_str(obj->get_data());
  28 }
  29
  30 void encode_json(const char *name, const rgw_user& val, Formatter *f)
  31 {
  32   f->dump_string(name, val.to_str());
  33 }
  34
  35 void encode_xml(const char *name, const rgw_user& val, Formatter *f)
  36 {
  37   encode_xml(name, val.to_str(), f);
  38 }
  39
  40 rgw_bucket::rgw_bucket(const rgw_user& u, const cls_user_bucket& b) :
  41     tenant(u.tenant),
  42     name(b.name),
  43     marker(b.marker),
  44     bucket_id(b.bucket_id),
  45     explicit_placement(b.explicit_placement.data_pool,
  46                        b.explicit_placement.data_extra_pool,
  47                        b.explicit_placement.index_pool)
  48 {
  49 }
  50
  51 void rgw_bucket::convert(cls_user_bucket *b) const
  52 {
  53   b->name = name;
  54   b->marker = marker;
  55   b->bucket_id = bucket_id;
  56   b->explicit_placement.data_pool = explicit_placement.data_pool.to_str();
  57   b->explicit_placement.data_extra_pool = explicit_placement.data_extra_pool.to_str();
  58   b->explicit_placement.index_pool = explicit_placement.index_pool.to_str();
  59 }
  60
  61 std::string rgw_bucket::get_key(char tenant_delim, char id_delim, size_t reserve) const
  62 {
  63   const size_t max_len = tenant.size() + sizeof(tenant_delim) +
  64       name.size() + sizeof(id_delim) + bucket_id.size() + reserve;
  65
  66   std::string key;
  67   key.reserve(max_len);
  68   if (!tenant.empty() && tenant_delim) {
  69     key.append(tenant);
  70     key.append(1, tenant_delim);
  71   }
  72   key.append(name);
  73   if (!bucket_id.empty() && id_delim) {
  74     key.append(1, id_delim);
  75     key.append(bucket_id);
  76   }
  77   return key;
  78 }
  79
  80 void rgw_bucket::generate_test_instances(list<rgw_bucket*>& o)
  81 {
  82   rgw_bucket *b = new rgw_bucket;
  83   init_bucket(b, "tenant", "name", "pool", ".index_pool", "marker", "123");
  84   o.push_back(b);
  85   o.push_back(new rgw_bucket);
  86 }
  87
  88 std::string rgw_bucket_shard::get_key(char tenant_delim, char id_delim,
  89                                       char shard_delim, size_t reserve) const
  90 {
  91   static constexpr size_t shard_len{12}; // ":4294967295\0"
  92   auto key = bucket.get_key(tenant_delim, id_delim, reserve + shard_len);
  93   if (shard_id >= 0 && shard_delim) {
  94     key.append(1, shard_delim);
  95     key.append(std::to_string(shard_id));
  96   }
  97   return key;
  98 }
  99
 100 void encode(const rgw_bucket_shard& b, bufferlist& bl, uint64_t f)
 101 {
 102   encode(b.bucket, bl, f);
 103   encode(b.shard_id, bl, f);
 104 }
 105
 106 void decode(rgw_bucket_shard& b, bufferlist::const_iterator& bl)
 107 {
 108   decode(b.bucket, bl);
 109   decode(b.shard_id, bl);
 110 }
 111
 112 void encode_json_impl(const char *name, const rgw_zone_id& zid, Formatter *f)
 113 {
 114   encode_json(name, zid.id, f);
 115 }
 116
 117 void decode_json_obj(rgw_zone_id& zid, JSONObj *obj)
 118 {
 119   decode_json_obj(zid.id, obj);
 120 }
 121
 122 void rgw_user::generate_test_instances(list<rgw_user*>& o)
 123 {
 124   rgw_user *u = new rgw_user("tenant", "user");
 125
 126   o.push_back(u);
 127   o.push_back(new rgw_user);
 128 }
 129
 130 void rgw_data_placement_target::dump(Formatter *f) const
 131 {
 132   encode_json("data_pool", data_pool, f);
 133   encode_json("data_extra_pool", data_extra_pool, f);
 134   encode_json("index_pool", index_pool, f);
 135 }
 136
 137 void rgw_data_placement_target::decode_json(JSONObj *obj) {
 138   JSONDecoder::decode_json("data_pool", data_pool, obj);
 139   JSONDecoder::decode_json("data_extra_pool", data_extra_pool, obj);
 140   JSONDecoder::decode_json("index_pool", index_pool, obj);
 141 }
 142
 143 void rgw_bucket::dump(Formatter *f) const
 144 {
 145   encode_json("name", name, f);
 146   encode_json("marker", marker, f);
 147   encode_json("bucket_id", bucket_id, f);
 148   encode_json("tenant", tenant, f);
 149   encode_json("explicit_placement", explicit_placement, f);
 150 }
 151
 152 void rgw_bucket::decode_json(JSONObj *obj) {
 153   JSONDecoder::decode_json("name", name, obj);
 154   JSONDecoder::decode_json("marker", marker, obj);
 155   JSONDecoder::decode_json("bucket_id", bucket_id, obj);
 156   JSONDecoder::decode_json("tenant", tenant, obj);
 157   JSONDecoder::decode_json("explicit_placement", explicit_placement, obj);
 158   if (explicit_placement.data_pool.empty()) {
 159     /* decoding old format */
 160     JSONDecoder::decode_json("pool", explicit_placement.data_pool, obj);
 161     JSONDecoder::decode_json("data_extra_pool", explicit_placement.data_extra_pool, obj);
 162     JSONDecoder::decode_json("index_pool", explicit_placement.index_pool, obj);
 163   }
 164 }
 165
 166 namespace rgw {
 167 namespace auth {
 168 ostream& operator <<(ostream& m, const Principal& p) {
 169   if (p.is_wildcard()) {
 170     return m << "*";
 171   }
 172
 173   m << "arn:aws:iam:" << p.get_tenant() << ":";
 174   if (p.is_tenant()) {
 175     return m << "root";
 176   }
 177   return m << (p.is_user() ? "user/" : "role/") << p.get_id();
 178 }
 179 }
 180 }