← Back to branch summary

~ubuntu-branches/ubuntu/precise/rpm/precise-proposed

« back to all changes in this revision

Viewing changes to db/test/rep024.tcl

  • Committer: Bazaar Package Importer
  • Author(s): Michael Vogt
  • Date: 2009-06-25 18:57:20 UTC
  • mfrom: (1.1.5 upstream) (4.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090625185720-617sjskgtgmf09vf
Tags: 4.7.0-7ubuntu1
* Merge from debian unstable, remaining changes:
  - change build depends from libdwarf-dev -> libdw-dev
    (libdwarf-dev is in universe)

Show diffs side-by-side

added added

removed removed

Lines of Context:
db/test/rep024.tcl
1
 
# See the file LICENSE for redistribution information.
2
 
#
3
 
# Copyright (c) 2004
4
 
#       Sleepycat Software.  All rights reserved.
5
 
#
6
 
# $Id: rep024.tcl,v 1.7 2004/09/22 18:01:06 bostic Exp $
7
 
#
8
 
# TEST          rep024
9
 
# TEST  Replication page allocation / verify test
10
 
# TEST
11
 
# TEST  Start a master (site 1) and a client (site 2).  Master
12
 
# TEST  closes (simulating a crash).  Site 2 becomes the master
13
 
# TEST  and site 1 comes back up as a client.  Verify database.
14
 
 
15
 
proc rep024 { method { niter 1000 } { tnum "024" } args } {
16
 
        global fixed_len
17
 
 
18
 
        set orig_fixed_len $fixed_len
19
 
        set fixed_len 448
20
 
        set args [convert_args $method $args]
21
 
        set logsets [create_logsets 2]
22
 
 
23
 
        # Run all tests with and without recovery.
24
 
        set envargs ""
25
 
        set recopts { "" "-recover" }
26
 
        foreach r $recopts {
27
 
                foreach l $logsets {
28
 
                        set logindex [lsearch -exact $l "in-memory"]
29
 
                        if { $r == "-recover" && $logindex != -1 } {
30
 
                                puts "Rep$tnum: Skipping\
31
 
                                    for in-memory logs with -recover."
32
 
                                continue
33
 
                        }
34
 
                        puts "Rep$tnum ($method $r): \
35
 
                            Replication page allocation/verify test."
36
 
                        puts "Rep$tnum: Master logs are [lindex $l 0]"
37
 
                        puts "Rep$tnum: Client logs are [lindex $l 1]"
38
 
                        rep024_sub $method $niter $tnum $envargs $l $r $args
39
 
                }
40
 
        }
41
 
        set fixed_len $orig_fixed_len
42
 
        return
43
 
}
44
 
 
45
 
proc rep024_sub { method niter tnum envargs logset recargs largs } {
46
 
        source ./include.tcl
47
 
        global testdir
48
 
        env_cleanup $testdir
49
 
 
50
 
        replsetup $testdir/MSGQUEUEDIR
51
 
 
52
 
        set masterdir $testdir/MASTERDIR
53
 
        set clientdir $testdir/CLIENTDIR
54
 
 
55
 
        file mkdir $masterdir
56
 
        file mkdir $clientdir
57
 
        set m_logtype [lindex $logset 0]
58
 
        set c_logtype [lindex $logset 1]
59
 
 
60
 
        # In-memory logs require a large log buffer, and cannot
61
 
        # be used with -txn nosync.  This test requires -txn, so
62
 
        # we only have to adjust the logargs.
63
 
        set m_logargs [adjust_logargs $m_logtype]
64
 
        set c_logargs [adjust_logargs $c_logtype]
65
 
 
66
 
        if { [is_record_based $method] == 1 } {
67
 
                set checkfunc test024_recno.check
68
 
        } else {
69
 
                set checkfunc test024.check
70
 
        }
71
 
 
72
 
        # Open a master.
73
 
        repladd 1
74
 
        set env_cmd(1) "berkdb_env_noerr -create -lock_max 2500 \
75
 
            -log_max 1000000 $envargs $recargs -home $masterdir \
76
 
            -errpfx MASTER -txn $m_logargs \
77
 
            -rep_transport \[list 1 replsend\]"
78
 
#       set env_cmd(1) "berkdb_env_noerr -create -lock_max 2500 \
79
 
#           -log_max 1000000 $envargs $recargs -home $masterdir \
80
 
#           -verbose {rep on} -errfile /dev/stderr \
81
 
#           -errpfx MASTER -txn $m_logargs \
82
 
#           -rep_transport \[list 1 replsend\]"
83
 
        set masterenv [eval $env_cmd(1) -rep_master]
84
 
        error_check_good master_env [is_valid_env $masterenv] TRUE
85
 
 
86
 
        # Open a client
87
 
        repladd 2
88
 
        set env_cmd(2) "berkdb_env_noerr -create -lock_max 2500 \
89
 
            -log_max 1000000 $envargs $recargs -home $clientdir \
90
 
            -errpfx CLIENT -txn $c_logargs \
91
 
            -rep_transport \[list 2 replsend\]"
92
 
#       set env_cmd(2) "berkdb_env_noerr -create -lock_max 2500 \
93
 
#           -log_max 1000000 $envargs $recargs -home $clientdir \
94
 
#           -verbose {rep on} -errfile /dev/stderr \
95
 
#           -errpfx CLIENT -txn $c_logargs \
96
 
#           -rep_transport \[list 2 replsend\]"
97
 
        set clientenv [eval $env_cmd(2) -rep_client]
98
 
        error_check_good client_env [is_valid_env $clientenv] TRUE
99
 
 
100
 
        # Bring the client online by processing the startup messages.
101
 
        set envlist "{$masterenv 1} {$clientenv 2}"
102
 
        process_msgs $envlist
103
 
 
104
 
        puts "\tRep$tnum.a: Add data to master, update client."
105
 
        #
106
 
        # This test uses a small page size and a large fixed_len
107
 
        # so it is easy to force a page allocation.
108
 
        set key [expr $niter + 1]
109
 
        set data A
110
 
        set pagesize 512
111
 
        if { [is_fixed_length $method] == 1 } {
112
 
                set bigdata [repeat $data [expr $pagesize / 2]]
113
 
        } else {
114
 
                set bigdata [repeat $data [expr 2 * $pagesize]]
115
 
        }
116
 
 
117
 
        set omethod [convert_method $method]
118
 
        set testfile "test$tnum.db"
119
 
        set db [eval "berkdb_open -create $omethod -auto_commit \
120
 
            -pagesize $pagesize -env $masterenv $largs $testfile"]
121
 
        eval rep_test $method $masterenv $db $niter 0 0
122
 
        process_msgs $envlist
123
 
 
124
 
        # Close client.  Force a page allocation on the master.
125
 
        # An overflow page (or big page, for hash) will do the job.
126
 
        #
127
 
        puts "\tRep$tnum.b: Close client, force page allocation on master."
128
 
        error_check_good client_close [$clientenv close] 0
129
 
#       error_check_good client_verify \
130
 
#           [verify_dir $clientdir "\tRep$tnum.b: " 0 0 1] 0
131
 
        set pages1 [r24_check_pages $db $method]
132
 
        set txn [$masterenv txn]
133
 
        error_check_good put_bigdata [eval {$db put} \
134
 
            -txn $txn {$key [chop_data $method $bigdata]}] 0
135
 
        error_check_good txn_commit [$txn commit] 0
136
 
 
137
 
        # Verify that we have allocated new pages.
138
 
        set pages2 [r24_check_pages $db $method]
139
 
        set newpages [expr $pages2 - $pages1]
140
 
 
141
 
        # Close master and discard messages for site 2.  Now everybody
142
 
        # is closed and sites 1 and 2 have different contents.
143
 
        puts "\tRep$tnum.c: Close master."
144
 
        error_check_good db_close [$db close] 0
145
 
        error_check_good master_close [$masterenv close] 0
146
 
        if { $newpages <= 0 } {
147
 
                puts "FAIL: no new pages allocated."
148
 
                return
149
 
        }
150
 
        error_check_good master_verify \
151
 
            [verify_dir $masterdir "\tRep$tnum.c: " 0 0 1] 0
152
 
 
153
 
        # Run a loop, opening the original client as master and the
154
 
        # original master as client.  Test db_verify.
155
 
        foreach option { "no new data" "add new data" } {
156
 
                puts "\tRep$tnum.d: Swap master and client ($option)."
157
 
                set newmasterenv [eval $env_cmd(2) -rep_master]
158
 
                set newclientenv [eval $env_cmd(1) -rep_client]
159
 
                set envlist "{$newmasterenv 2} {$newclientenv 1}"
160
 
                process_msgs $envlist
161
 
                if { $option == "add new data" } {
162
 
                        set key [expr $niter + 2]
163
 
                        set db [eval "berkdb_open -create $omethod \
164
 
                            -auto_commit -pagesize $pagesize \
165
 
                            -env $newmasterenv $largs $testfile"]
166
 
                        set pages1 [r24_check_pages $db $method]
167
 
                        set txn [$newmasterenv txn]
168
 
                        error_check_good put_bigdata [eval {$db put} \
169
 
                            -txn $txn {$key [chop_data $method $bigdata]}] 0
170
 
                        error_check_good txn_commit [$txn commit] 0
171
 
                        set pages2 [r24_check_pages $db $method]
172
 
                        set newpages [expr $pages2 - $pages1]
173
 
                        error_check_good db_close [$db close] 0
174
 
                        process_msgs $envlist
175
 
                }
176
 
                puts "\tRep$tnum.e: Close master and client, run verify."
177
 
                error_check_good newmasterenv_close [$newmasterenv close] 0
178
 
                error_check_good newclientenv_close [$newclientenv close] 0
179
 
                if { $newpages <= 0 } {
180
 
                        puts "FAIL: no new pages allocated."
181
 
                        return
182
 
                }
183
 
                # This test can leave unreferenced pages on systems without
184
 
                # FTRUNCATE and that's OK, so set unref to 0.
185
 
                error_check_good verify \
186
 
                    [verify_dir $masterdir "\tRep$tnum.f: " 0 0 1 0 0] 0
187
 
                error_check_good verify \
188
 
                    [verify_dir $clientdir "\tRep$tnum.g: " 0 0 1 0 0] 0
189
 
        }
190
 
        replclose $testdir/MSGQUEUEDIR
191
 
}
192
 
 
193
 
proc r24_check_pages { db method } {
194
 
        if { [is_hash $method] == 1 } {
195
 
                set pages [stat_field $db stat "Number of big pages"]
196
 
        } elseif { [is_queue $method] == 1 } {
197
 
                set pages [stat_field $db stat "Number of pages"]
198
 
        } else {
199
 
                set pages [stat_field $db stat "Overflow pages"]
200
 
        }
201
 
        return $pages
202
 
}