← Back to branch summary

~raghavendra-prabhu/percona-xtradb-cluster/release-5.5.30-galera-2.x

« back to all changes in this revision

Viewing changes to galera/tests/ist_check.cpp

  • Committer: Ignacio Nin
  • Date: 2012-10-31 22:57:41 UTC
  • mfrom: (95.2.11 2.x)
  • Revision ID: ignacio.nin@percona.com-20121031225741-kzcz6072mwzfpaiw
Merge from upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
galera/tests/ist_check.cpp
86
86
    const std::string& peer_;
87
87
    wsrep_seqno_t first_;
88
88
    wsrep_seqno_t last_;
 
89
    int version_;
89
90
    sender_args(gcache::GCache& gcache,
90
91
                const std::string& peer,
91
 
                wsrep_seqno_t first, wsrep_seqno_t last)
 
92
                wsrep_seqno_t first, wsrep_seqno_t last,
 
93
                int version)
92
94
        :
93
95
        gcache_(gcache),
94
96
        peer_  (peer),
95
97
        first_ (first),
96
 
        last_  (last)
 
98
        last_  (last),
 
99
        version_(version)
97
100
    { }
98
101
};
99
102
 
104
107
    wsrep_seqno_t first_;
105
108
    wsrep_seqno_t last_;
106
109
    size_t        n_receivers_;
 
110
    int           version_;
107
111
    receiver_args(const std::string listen_addr,
108
112
        wsrep_seqno_t first, wsrep_seqno_t last,
109
 
                  size_t n_receivers)
 
113
                  size_t n_receivers, int version)
110
114
        :
111
115
        listen_addr_(listen_addr),
112
116
        first_(first),
113
117
        last_(last),
114
 
        n_receivers_(n_receivers)
 
118
        n_receivers_(n_receivers),
 
119
        version_(version)
115
120
    { }
116
121
};
117
122
 
131
136
    const sender_args* sargs(reinterpret_cast<const sender_args*>(arg));
132
137
    gu::Config conf;
133
138
    pthread_barrier_wait(&start_barrier);
134
 
    galera::ist::Sender sender(conf, sargs->gcache_, sargs->peer_, 1);
 
139
    galera::ist::Sender sender(conf, sargs->gcache_, sargs->peer_,
 
140
                               sargs->version_);
135
141
    sender.send(sargs->first_, sargs->last_);
136
142
    return 0;
137
143
}
167
173
    gu::Config conf;
168
174
    conf.set(galera::ist::Receiver::RECV_ADDR, rargs->listen_addr_);
169
175
    galera::ist::Receiver receiver(conf, 0);
170
 
    rargs->listen_addr_ = receiver.prepare(rargs->first_, rargs->last_, 1);
 
176
    rargs->listen_addr_ = receiver.prepare(rargs->first_, rargs->last_,
 
177
                                           rargs->version_);
171
178
 
172
179
    std::vector<pthread_t> threads(rargs->n_receivers_);
173
180
    trx_thread_args trx_thd_args(receiver);
192
199
}
193
200
 
194
201
 
 
202
static int select_trx_version(int protocol_version)
 
203
{
 
204
    // see protocol version table in replicator_smm.hpp
 
205
    switch (protocol_version)
 
206
    {
 
207
    case 1:
 
208
    case 2:
 
209
        return 1;
 
210
    case 3:
 
211
    case 4:
 
212
        return 2;
 
213
    }
 
214
    fail("unknown protocol version %i", protocol_version);
 
215
    return -1;
 
216
}
 
217
 
 
218
 
195
219
static void test_ist_common(int version)
196
220
{
197
221
    using galera::TrxHandle;
198
222
    using galera::Key;
 
223
    int trx_version(select_trx_version(version));
199
224
    gu::Config conf;
200
225
    std::string gcache_file("ist_check.cache");
201
226
    conf.set("gcache.name", gcache_file);
209
234
    // populate gcache
210
235
    for (size_t i(1); i <= 10; ++i)
211
236
    {
212
 
        TrxHandle* trx(new TrxHandle(0, uuid, 1234, 5678, false));
 
237
        TrxHandle* trx(new TrxHandle(trx_version, uuid, 1234, 5678, false));
213
238
        const wsrep_key_part_t key[2] = {
214
239
            {"key1", 4},
215
240
            {"key2", 4}
216
241
        };
217
 
        trx->append_key(Key(0, key, 2, version));
 
242
        trx->append_key(Key(trx_version, key, 2, 0));
218
243
        trx->append_data("bar", 3);
219
244
 
220
245
        size_t trx_size(serial_size(*trx));
224
249
        trx->unref();
225
250
    }
226
251
 
227
 
    receiver_args rargs(receiver_addr, 1, 10, 1);
228
 
    sender_args sargs(*gcache, rargs.listen_addr_, 1, 10);
 
252
    receiver_args rargs(receiver_addr, 1, 10, 1, version);
 
253
    sender_args sargs(*gcache, rargs.listen_addr_, 1, 10, version);
229
254
 
230
255
    pthread_barrier_init(&start_barrier, 0, 1 + 1 + rargs.n_receivers_);
231
256
 
232
 
 
233
257
    pthread_t sender_thread, receiver_thread;
234
258
    pthread_create(&sender_thread, 0, &sender_thd, &sargs);
235
259
    pthread_create(&receiver_thread, 0, &receiver_thd, &rargs);