← Back to branch summary

~ubuntu-branches/ubuntu/precise/ceph/precise

« back to all changes in this revision

Viewing changes to src/mon/MonMap.h

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum, Clint Byrum, Micah Gersten
  • Date: 2011-02-12 22:50:26 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110212225026-yyyw4tk0msgql3ul
Tags: 0.24.2-0ubuntu1
https://launchpad.net/bugs/658670
https://launchpad.net/bugs/684011
[ Clint Byrum <clint@ubuntu.com> ]
* New upstream release. (LP: #658670, LP: #684011)
* debian/patches/fix-mkcephfs.patch: dropped (applied upstream)
* Removed .la files from libceph1-dev, libcrush1-dev and 
  librados1-dev (per Debian policy v3.9.1 10.2).
* debian/control: adding pkg-config as a build dependency
* debian/control: depend on libcrypto++-dev instead of libssl-dev
* debian/watch: added watch file

[ Micah Gersten <micahg@ubuntu.com> ]
* debian/control: add Homepage

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mon/MonMap.h
25
25
 public:
26
26
  epoch_t epoch;       // what epoch/version of the monmap
27
27
  ceph_fsid_t fsid;
28
 
  vector<entity_inst_t> mon_inst;
 
28
  map<string, entity_addr_t> mon_addr;
29
29
  utime_t last_changed;
30
30
  utime_t created;
31
31
 
 
32
  vector<string> rank_name;
 
33
  vector<entity_addr_t> rank_addr;
 
34
  
 
35
  void calc_ranks() {
 
36
    rank_name.resize(mon_addr.size());
 
37
    rank_addr.resize(mon_addr.size());
 
38
    unsigned i = 0;
 
39
    for (map<string,entity_addr_t>::iterator p = mon_addr.begin();
 
40
         p != mon_addr.end();
 
41
         p++, i++) {
 
42
      rank_name[i] = p->first;
 
43
      rank_addr[i] = p->second;
 
44
    }
 
45
  }
 
46
 
32
47
  MonMap() : epoch(0) {
33
48
    memset(&fsid, 0, sizeof(fsid));
34
49
    last_changed = created = g_clock.now();
37
52
  ceph_fsid_t& get_fsid() { return fsid; }
38
53
 
39
54
  unsigned size() {
40
 
    return mon_inst.size();
 
55
    return mon_addr.size();
 
56
  }
 
57
 
 
58
  const string& pick_random_mon() {
 
59
    unsigned n = rand() % rank_name.size();
 
60
    return rank_name[n];
 
61
  }
 
62
  const string& pick_random_mon_not(const string& butnot) {
 
63
    unsigned n = rand() % rank_name.size();
 
64
    if (rank_name[n] == butnot && rank_name.size() > 1) {
 
65
      if (n)
 
66
        n--;
 
67
      else
 
68
        n++;
 
69
    }
 
70
    return rank_name[n];
41
71
  }
42
72
 
43
73
  epoch_t get_epoch() { return epoch; }
44
74
 
45
 
  void add_mon(entity_inst_t inst) {
46
 
    mon_inst.push_back(inst);
47
 
  }
48
 
 
49
 
  void add(entity_addr_t a) {
50
 
    entity_inst_t i;
51
 
    i.addr = a;
52
 
    i.name = entity_name_t::MON(mon_inst.size());
53
 
    mon_inst.push_back(i);
54
 
  }
55
 
  bool remove(entity_addr_t a) {
56
 
    for (unsigned i=0; i<mon_inst.size(); i++) {
57
 
      if (mon_inst[i].addr == a) {
58
 
        for (; i < mon_inst.size()-1; i++) 
59
 
          mon_inst[i].addr = mon_inst[i+1].addr;
60
 
        mon_inst.pop_back();
61
 
        return true;
62
 
      }
63
 
    }
64
 
    return false;
65
 
  }
 
75
  void add(string name, entity_addr_t addr) {
 
76
    assert(mon_addr.count(name) == 0);
 
77
    mon_addr[name] = addr;
 
78
    calc_ranks();
 
79
  }
 
80
  
 
81
  void remove(string name) {
 
82
    assert(mon_addr.count(name));
 
83
    mon_addr.erase(name);
 
84
    calc_ranks();
 
85
  }
 
86
 
 
87
  bool contains(const string& name) {
 
88
    return mon_addr.count(name);
 
89
  }
 
90
 
66
91
  bool contains(entity_addr_t a) {
67
 
    for (unsigned i=0; i<mon_inst.size(); i++)
68
 
      if (mon_inst[i].addr == a) 
69
 
        return true;
70
 
    return false;
71
 
  }
72
 
 
73
 
  const entity_inst_t &get_inst(unsigned m) {
74
 
    assert(m < mon_inst.size());
75
 
    return mon_inst[m];
 
92
    for (map<string,entity_addr_t>::iterator p = mon_addr.begin();
 
93
         p != mon_addr.end();
 
94
         p++)
 
95
      if (p->second == a)
 
96
        return true;
 
97
    return false;
 
98
  }
 
99
 
 
100
  int get_rank(const string& n) {
 
101
    for (unsigned i=0; i<rank_name.size(); i++)
 
102
      if (rank_name[i] == n)
 
103
        return i;
 
104
    return -1;
 
105
  }
 
106
  bool get_addr_name(entity_addr_t a, string& name) {
 
107
    for (map<string,entity_addr_t>::iterator p = mon_addr.begin();
 
108
         p != mon_addr.end();
 
109
         p++)
 
110
      if (p->second == a) {
 
111
        name = p->first;
 
112
        return true;
 
113
      }
 
114
    return false;
 
115
  }
 
116
 
 
117
  const entity_addr_t& get_addr(const string& n) {
 
118
    assert(mon_addr.count(n));
 
119
    return mon_addr[n];
 
120
  }
 
121
  const entity_addr_t& get_addr(unsigned m) {
 
122
    assert(m < rank_addr.size());
 
123
    return rank_addr[m];
 
124
  }
 
125
  entity_inst_t get_inst(const string& n) {
 
126
    assert(mon_addr.count(n));
 
127
    int m = get_rank(n);
 
128
    entity_inst_t i;
 
129
    i.addr = rank_addr[m];
 
130
    i.name = entity_name_t::MON(m);
 
131
    return i;
 
132
  }
 
133
  entity_inst_t get_inst(unsigned m) {
 
134
    assert(m < rank_addr.size());
 
135
    entity_inst_t i;
 
136
    i.addr = rank_addr[m];
 
137
    i.name = entity_name_t::MON(m);
 
138
    return i;
76
139
  }
77
140
 
78
141
  void encode(bufferlist& blist) {
 
142
    __u16 v = 2;
 
143
    ::encode(v, blist);
 
144
    ::encode_raw(fsid, blist);
 
145
    ::encode(epoch, blist);
 
146
    ::encode(mon_addr, blist);
 
147
    ::encode(last_changed, blist);
 
148
    ::encode(created, blist);
 
149
  }
 
150
  void encode_v1(bufferlist& blist) {
79
151
    __u16 v = 1;
80
152
    ::encode(v, blist);
81
153
    ::encode_raw(fsid, blist);
82
154
    ::encode(epoch, blist);
 
155
    vector<entity_inst_t> mon_inst(mon_addr.size());
 
156
    for (unsigned n = 0; n < mon_addr.size(); n++)
 
157
      mon_inst[n] = get_inst(n);
83
158
    ::encode(mon_inst, blist);
84
159
    ::encode(last_changed, blist);
85
160
    ::encode(created, blist);
86
 
  }  
 
161
  }
 
162
 
87
163
  void decode(bufferlist& blist) {
88
164
    bufferlist::iterator p = blist.begin();
89
165
    decode(p);
93
169
    ::decode(v, p);
94
170
    ::decode_raw(fsid, p);
95
171
    ::decode(epoch, p);
96
 
    ::decode(mon_inst, p);
 
172
    if (v == 1) {
 
173
      vector<entity_inst_t> mon_inst;
 
174
      ::decode(mon_inst, p);
 
175
      for (unsigned i = 0; i < mon_inst.size(); i++) {
 
176
        char n[2];
 
177
        n[0] = '0' + i;
 
178
        n[1] = 0;
 
179
        string name = n;
 
180
        mon_addr[name] = mon_inst[i].addr;
 
181
      }
 
182
    } else
 
183
      ::decode(mon_addr, p);
97
184
    ::decode(last_changed, p);
98
185
    ::decode(created, p);
 
186
    calc_ranks();
99
187
  }
100
188
 
101
 
 
102
189
  void generate_fsid() {
103
190
    for (int i=0; i<16; i++)
104
191
      fsid.fsid[i] = rand();
108
195
  int write(const char *fn);
109
196
  int read(const char *fn);
110
197
 
111
 
  void print(ostream& out);
112
 
  void print_summary(ostream& out);
 
198
  void print(ostream& out) const;
 
199
  void print_summary(ostream& out) const;
113
200
};
114
201
 
115
202
inline void encode(MonMap &m, bufferlist &bl) {