ceph/src/rgw/rgw_lc.h

   1 #ifndef CEPH_RGW_LC_H
   2 #define CEPH_RGW_LC_H
   3
   4 #include <map>
   5 #include <string>
   6 #include <iostream>
   7 #include <include/types.h>
   8
   9 #include "common/debug.h"
  10
  11 #include "include/types.h"
  12 #include "include/rados/librados.hpp"
  13 #include "common/Mutex.h"
  14 #include "common/Cond.h"
  15 #include "common/Thread.h"
  16 #include "rgw_common.h"
  17 #include "rgw_rados.h"
  18 #include "rgw_multi.h"
  19 #include "cls/rgw/cls_rgw_types.h"
  20
  21 #include <atomic>
  22
  23 #define HASH_PRIME 7877
  24 #define MAX_ID_LEN 255
  25 static string lc_oid_prefix = "lc";
  26 static string lc_index_lock_name = "lc_process";
  27
  28 extern const char* LC_STATUS[];
  29
  30 typedef enum {
  31   lc_uninitial = 0,
  32   lc_processing,
  33   lc_failed,
  34   lc_complete,
  35 }LC_BUCKET_STATUS;
  36
  37 class LCExpiration
  38 {
  39 protected:
  40   string days;
  41 public:
  42   LCExpiration() {}
  43   ~LCExpiration() {}
  44
  45   void encode(bufferlist& bl) const {
  46     ENCODE_START(2, 2, bl);
  47     ::encode(days, bl);
  48     ENCODE_FINISH(bl);
  49   }
  50   void decode(bufferlist::iterator& bl) {
  51     DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
  52     ::decode(days, bl);
  53     DECODE_FINISH(bl);
  54   }
  55   void dump(Formatter *f) const;
  56 //  static void generate_test_instances(list<ACLOwner*>& o);
  57   void set_days(const string& _days) { days = _days; }
  58   string get_days_str() const{
  59     return days;
  60   }
  61   int get_days() {return atoi(days.c_str()); }
  62   bool empty() const{
  63     return days.empty();
  64   }
  65 };
  66 WRITE_CLASS_ENCODER(LCExpiration)
  67
  68 class LCRule
  69 {
  70 protected:
  71   string id;
  72   string prefix;
  73   string status;
  74   LCExpiration expiration;
  75   LCExpiration noncur_expiration;
  76   LCExpiration mp_expiration;
  77   bool dm_expiration;
  78
  79 public:
  80
  81   LCRule(){};
  82   ~LCRule(){};
  83
  84   bool get_id(string& _id) {
  85       _id = id;
  86       return true;
  87   }
  88
  89   string& get_status() {
  90       return status;
  91   }
  92
  93   string& get_prefix() {
  94       return prefix;
  95   }
  96
  97   LCExpiration& get_expiration() {
  98     return expiration;
  99   }
 100
 101   LCExpiration& get_noncur_expiration() {
 102     return noncur_expiration;
 103   }
 104
 105   LCExpiration& get_mp_expiration() {
 106     return mp_expiration;
 107   }
 108
 109   bool get_dm_expiration() {
 110     return dm_expiration;
 111   }
 112
 113   void set_id(string*_id) {
 114     id = *_id;
 115   }
 116
 117   void set_prefix(string*_prefix) {
 118     prefix = *_prefix;
 119   }
 120
 121   void set_status(string*_status) {
 122     status = *_status;
 123   }
 124
 125   void set_expiration(LCExpiration*_expiration) {
 126     expiration = *_expiration;
 127   }
 128
 129   void set_noncur_expiration(LCExpiration*_noncur_expiration) {
 130     noncur_expiration = *_noncur_expiration;
 131   }
 132
 133   void set_mp_expiration(LCExpiration* _mp_expiration) {
 134     mp_expiration = *_mp_expiration;
 135   }
 136
 137   void set_dm_expiration(bool _dm_expiration) {
 138     dm_expiration = _dm_expiration;
 139   }
 140
 141   bool validate();
 142
 143   void encode(bufferlist& bl) const {
 144      ENCODE_START(4, 1, bl);
 145      ::encode(id, bl);
 146      ::encode(prefix, bl);
 147      ::encode(status, bl);
 148      ::encode(expiration, bl);
 149      ::encode(noncur_expiration, bl);
 150      ::encode(mp_expiration, bl);
 151      ::encode(dm_expiration, bl);
 152      ENCODE_FINISH(bl);
 153    }
 154    void decode(bufferlist::iterator& bl) {
 155      DECODE_START_LEGACY_COMPAT_LEN(4, 1, 1, bl);
 156      ::decode(id, bl);
 157      ::decode(prefix, bl);
 158      ::decode(status, bl);
 159      ::decode(expiration, bl);
 160      if (struct_v >=2) {
 161        ::decode(noncur_expiration, bl);
 162      }
 163      if (struct_v >= 3) {
 164        ::decode(mp_expiration, bl);
 165      }
 166      if (struct_v >= 4) {
 167         ::decode(dm_expiration, bl);
 168      }
 169      DECODE_FINISH(bl);
 170    }
 171
 172 };
 173 WRITE_CLASS_ENCODER(LCRule)
 174
 175 struct lc_op
 176 {
 177   bool status;
 178   bool dm_expiration;
 179   int expiration;
 180   int noncur_expiration;
 181   int mp_expiration;
 182
 183   lc_op() : status(false), dm_expiration(false), expiration(0), noncur_expiration(0), mp_expiration(0) {}
 184
 185 };
 186
 187 class RGWLifecycleConfiguration
 188 {
 189 protected:
 190   CephContext *cct;
 191   map<string, lc_op> prefix_map;
 192   multimap<string, LCRule> rule_map;
 193   bool _add_rule(LCRule *rule);
 194 public:
 195   RGWLifecycleConfiguration(CephContext *_cct) : cct(_cct) {}
 196   RGWLifecycleConfiguration() : cct(NULL) {}
 197
 198   void set_ctx(CephContext *ctx) {
 199     cct = ctx;
 200   }
 201
 202   virtual ~RGWLifecycleConfiguration() {}
 203
 204 //  int get_perm(string& id, int perm_mask);
 205 //  int get_group_perm(ACLGroupTypeEnum group, int perm_mask);
 206   void encode(bufferlist& bl) const {
 207     ENCODE_START(1, 1, bl);
 208     ::encode(rule_map, bl);
 209     ENCODE_FINISH(bl);
 210   }
 211   void decode(bufferlist::iterator& bl) {
 212     DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
 213     ::decode(rule_map, bl);
 214     multimap<string, LCRule>::iterator iter;
 215     for (iter = rule_map.begin(); iter != rule_map.end(); ++iter) {
 216       LCRule& rule = iter->second;
 217       _add_rule(&rule);
 218     }
 219     DECODE_FINISH(bl);
 220   }
 221   void dump(Formatter *f) const;
 222 //  static void generate_test_instances(list<RGWAccessControlList*>& o);
 223
 224   void add_rule(LCRule* rule);
 225
 226   int check_and_add_rule(LCRule* rule);
 227
 228   bool validate();
 229
 230   multimap<string, LCRule>& get_rule_map() { return rule_map; }
 231   map<string, lc_op>& get_prefix_map() { return prefix_map; }
 232 /*
 233   void create_default(string id, string name) {
 234     ACLGrant grant;
 235     grant.set_canon(id, name, RGW_PERM_FULL_CONTROL);
 236     add_grant(&grant);
 237   }
 238 */
 239 };
 240 WRITE_CLASS_ENCODER(RGWLifecycleConfiguration)
 241
 242 class RGWLC {
 243   CephContext *cct;
 244   RGWRados *store;
 245   int max_objs;
 246   string *obj_names;
 247   std::atomic<bool> down_flag = { false };
 248   string cookie;
 249
 250   class LCWorker : public Thread {
 251     CephContext *cct;
 252     RGWLC *lc;
 253     Mutex lock;
 254     Cond cond;
 255
 256   public:
 257     LCWorker(CephContext *_cct, RGWLC *_lc) : cct(_cct), lc(_lc), lock("LCWorker") {}
 258     void *entry() override;
 259     void stop();
 260     bool should_work(utime_t& now);
 261     int schedule_next_start_time(utime_t& start, utime_t& now);
 262   };
 263
 264   public:
 265   LCWorker *worker;
 266   RGWLC() : cct(NULL), store(NULL), worker(NULL) {}
 267   ~RGWLC() {
 268     stop_processor();
 269     finalize();
 270   }
 271
 272   void initialize(CephContext *_cct, RGWRados *_store);
 273   void finalize();
 274
 275   int process();
 276   int process(int index, int max_secs);
 277   bool if_already_run_today(time_t& start_date);
 278   int list_lc_progress(const string& marker, uint32_t max_entries, map<string, int> *progress_map);
 279   int bucket_lc_prepare(int index);
 280   int bucket_lc_process(string& shard_id);
 281   int bucket_lc_post(int index, int max_lock_sec, pair<string, int >& entry, int& result);
 282   bool going_down();
 283   void start_processor();
 284   void stop_processor();
 285
 286   private:
 287   int remove_expired_obj(RGWBucketInfo& bucket_info, rgw_obj_key obj_key, bool remove_indeed = true);
 288   bool obj_has_expired(double timediff, int days);
 289   int handle_multipart_expiration(RGWRados::Bucket *target, const map<string, lc_op>& prefix_map);
 290 };
 291
 292
 293
 294 #endif