← Back to branch summary

~ubuntu-branches/ubuntu/trusty/swift/trusty-updates

« back to all changes in this revision

Viewing changes to test/probe/test_account_failures.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Soren Hansen, Chuck Short
  • Date: 2012-09-07 19:02:36 UTC
  • mfrom: (1.2.12)
  • Revision ID: package-import@ubuntu.com-20120907190236-fqrmbzm7v6zivs8d
Tags: 1.7.0-0ubuntu1
[ Soren Hansen ]
* Update debian/watch to account for symbolically named tarballs and
  use newer URL.
* Run unit tests at build time.
* Fix Launchpad URLs in debian/watch.

[ Chuck Short ]
* New upstream release
* debian/control: Add pubthon-moc as a build dep
* debian/rules: Dont fail if testsuite fails.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/probe/test_account_failures.py
14
14
# See the License for the specific language governing permissions and
15
15
# limitations under the License.
16
16
 
17
 
import unittest
18
 
from os import kill
19
 
from signal import SIGTERM
20
17
from subprocess import Popen
21
 
from time import sleep
 
18
from unittest import main, TestCase
22
19
 
23
20
from swiftclient import client
 
21
 
24
22
from swift.common import direct_client
25
 
from test.probe.common import get_to_final_state, kill_pids, reset_environment
26
 
 
27
 
 
28
 
class TestAccountFailures(unittest.TestCase):
 
23
from test.probe.common import get_to_final_state, kill_nonprimary_server, \
 
24
    kill_server, kill_servers, reset_environment, start_server
 
25
 
 
26
 
 
27
class TestAccountFailures(TestCase):
29
28
 
30
29
    def setUp(self):
31
 
        self.pids, self.port2server, self.account_ring, self.container_ring, \
32
 
            self.object_ring, self.url, self.token, self.account = \
33
 
                reset_environment()
 
30
        (self.pids, self.port2server, self.account_ring, self.container_ring,
 
31
         self.object_ring, self.url, self.token,
 
32
         self.account) = reset_environment()
34
33
 
35
34
    def tearDown(self):
36
 
        kill_pids(self.pids)
 
35
        kill_servers(self.port2server, self.pids)
37
36
 
38
37
    def test_main(self):
 
38
        # Create container1 and container2
 
39
        # Assert account level sees them
 
40
        # Create container2/object1
 
41
        # Assert account level doesn't see it yet
 
42
        # Get to final state
 
43
        # Assert account level now sees the container2/object1
 
44
        # Kill account servers excepting two of the primaries
 
45
        # Delete container1
 
46
        # Assert account level knows container1 is gone but doesn't know about
 
47
        #   container2/object2 yet
 
48
        # Put container2/object2
 
49
        # Run container updaters
 
50
        # Assert account level now knows about container2/object2
 
51
        # Restart other primary account server
 
52
        # Assert that server doesn't know about container1's deletion or the
 
53
        #   new container2/object2 yet
 
54
        # Get to final state
 
55
        # Assert that server is now up to date
 
56
 
39
57
        container1 = 'container1'
40
58
        client.put_container(self.url, self.token, container1)
41
59
        container2 = 'container2'
46
64
        self.assertEquals(headers['x-account-bytes-used'], '0')
47
65
        found1 = False
48
66
        found2 = False
49
 
        for c in containers:
50
 
            if c['name'] == container1:
 
67
        for container in containers:
 
68
            if container['name'] == container1:
51
69
                found1 = True
52
 
                self.assertEquals(c['count'], 0)
53
 
                self.assertEquals(c['bytes'], 0)
54
 
            elif c['name'] == container2:
 
70
                self.assertEquals(container['count'], 0)
 
71
                self.assertEquals(container['bytes'], 0)
 
72
            elif container['name'] == container2:
55
73
                found2 = True
56
 
                self.assertEquals(c['count'], 0)
57
 
                self.assertEquals(c['bytes'], 0)
 
74
                self.assertEquals(container['count'], 0)
 
75
                self.assertEquals(container['bytes'], 0)
58
76
        self.assert_(found1)
59
77
        self.assert_(found2)
60
78
 
65
83
        self.assertEquals(headers['x-account-bytes-used'], '0')
66
84
        found1 = False
67
85
        found2 = False
68
 
        for c in containers:
69
 
            if c['name'] == container1:
 
86
        for container in containers:
 
87
            if container['name'] == container1:
70
88
                found1 = True
71
 
                self.assertEquals(c['count'], 0)
72
 
                self.assertEquals(c['bytes'], 0)
73
 
            elif c['name'] == container2:
 
89
                self.assertEquals(container['count'], 0)
 
90
                self.assertEquals(container['bytes'], 0)
 
91
            elif container['name'] == container2:
74
92
                found2 = True
75
 
                self.assertEquals(c['count'], 0)
76
 
                self.assertEquals(c['bytes'], 0)
 
93
                self.assertEquals(container['count'], 0)
 
94
                self.assertEquals(container['bytes'], 0)
77
95
        self.assert_(found1)
78
96
        self.assert_(found2)
79
97
 
84
102
        self.assertEquals(headers['x-account-bytes-used'], '4')
85
103
        found1 = False
86
104
        found2 = False
87
 
        for c in containers:
88
 
            if c['name'] == container1:
 
105
        for container in containers:
 
106
            if container['name'] == container1:
89
107
                found1 = True
90
 
                self.assertEquals(c['count'], 0)
91
 
                self.assertEquals(c['bytes'], 0)
92
 
            elif c['name'] == container2:
 
108
                self.assertEquals(container['count'], 0)
 
109
                self.assertEquals(container['bytes'], 0)
 
110
            elif container['name'] == container2:
93
111
                found2 = True
94
 
                self.assertEquals(c['count'], 1)
95
 
                self.assertEquals(c['bytes'], 4)
 
112
                self.assertEquals(container['count'], 1)
 
113
                self.assertEquals(container['bytes'], 4)
96
114
        self.assert_(found1)
97
115
        self.assert_(found2)
98
116
 
99
117
        apart, anodes = self.account_ring.get_nodes(self.account)
100
 
        kill(self.pids[self.port2server[anodes[0]['port']]], SIGTERM)
 
118
        kill_nonprimary_server(anodes, self.port2server, self.pids)
 
119
        kill_server(anodes[0]['port'], self.port2server, self.pids)
101
120
 
102
121
        client.delete_container(self.url, self.token, container1)
103
122
        client.put_object(self.url, self.token, container2, 'object2', '12345')
107
126
        self.assertEquals(headers['x-account-bytes-used'], '4')
108
127
        found1 = False
109
128
        found2 = False
110
 
        for c in containers:
111
 
            if c['name'] == container1:
 
129
        for container in containers:
 
130
            if container['name'] == container1:
112
131
                found1 = True
113
 
            elif c['name'] == container2:
 
132
            elif container['name'] == container2:
114
133
                found2 = True
115
 
                self.assertEquals(c['count'], 1)
116
 
                self.assertEquals(c['bytes'], 4)
 
134
                self.assertEquals(container['count'], 1)
 
135
                self.assertEquals(container['bytes'], 4)
117
136
        self.assert_(not found1)
118
137
        self.assert_(found2)
119
138
 
120
 
        ps = []
121
 
        for n in xrange(1, 5):
122
 
            ps.append(Popen(['swift-container-updater',
123
 
                             '/etc/swift/container-server/%d.conf' % n,
124
 
                             'once']))
125
 
        for p in ps:
126
 
            p.wait()
 
139
        processes = []
 
140
        for node in xrange(1, 5):
 
141
            processes.append(Popen([
 
142
                'swift-container-updater',
 
143
                '/etc/swift/container-server/%d.conf' % node,
 
144
                'once']))
 
145
        for process in processes:
 
146
            process.wait()
127
147
        headers, containers = client.get_account(self.url, self.token)
128
148
        self.assertEquals(headers['x-account-container-count'], '1')
129
149
        self.assertEquals(headers['x-account-object-count'], '2')
130
150
        self.assertEquals(headers['x-account-bytes-used'], '9')
131
151
        found1 = False
132
152
        found2 = False
133
 
        for c in containers:
134
 
            if c['name'] == container1:
 
153
        for container in containers:
 
154
            if container['name'] == container1:
135
155
                found1 = True
136
 
            elif c['name'] == container2:
 
156
            elif container['name'] == container2:
137
157
                found2 = True
138
 
                self.assertEquals(c['count'], 2)
139
 
                self.assertEquals(c['bytes'], 9)
 
158
                self.assertEquals(container['count'], 2)
 
159
                self.assertEquals(container['bytes'], 9)
140
160
        self.assert_(not found1)
141
161
        self.assert_(found2)
142
162
 
143
 
        self.pids[self.port2server[anodes[0]['port']]] = \
144
 
            Popen(['swift-account-server',
145
 
                   '/etc/swift/account-server/%d.conf' %
146
 
                    ((anodes[0]['port'] - 6002) / 10)]).pid
147
 
        sleep(2)
148
 
        # This is the earlier counts and bytes because the first node doesn't
149
 
        # have the newest udpates yet.
 
163
        start_server(anodes[0]['port'], self.port2server, self.pids)
 
164
 
150
165
        headers, containers = \
151
166
            direct_client.direct_get_account(anodes[0], apart, self.account)
152
167
        self.assertEquals(headers['x-account-container-count'], '2')
154
169
        self.assertEquals(headers['x-account-bytes-used'], '4')
155
170
        found1 = False
156
171
        found2 = False
157
 
        for c in containers:
158
 
            if c['name'] == container1:
 
172
        for container in containers:
 
173
            if container['name'] == container1:
159
174
                found1 = True
160
 
            elif c['name'] == container2:
 
175
            elif container['name'] == container2:
161
176
                found2 = True
162
 
                # This is the earlier count and bytes because the first node
163
 
                # doesn't have the newest udpates yet.
164
 
                self.assertEquals(c['count'], 1)
165
 
                self.assertEquals(c['bytes'], 4)
166
 
        # This okay because the first node hasn't got the update that
167
 
        # container1 was deleted yet.
 
177
                self.assertEquals(container['count'], 1)
 
178
                self.assertEquals(container['bytes'], 4)
168
179
        self.assert_(found1)
169
180
        self.assert_(found2)
170
181
 
176
187
        self.assertEquals(headers['x-account-bytes-used'], '9')
177
188
        found1 = False
178
189
        found2 = False
179
 
        for c in containers:
180
 
            if c['name'] == container1:
 
190
        for container in containers:
 
191
            if container['name'] == container1:
181
192
                found1 = True
182
 
            elif c['name'] == container2:
 
193
            elif container['name'] == container2:
183
194
                found2 = True
184
 
                self.assertEquals(c['count'], 2)
185
 
                self.assertEquals(c['bytes'], 9)
 
195
                self.assertEquals(container['count'], 2)
 
196
                self.assertEquals(container['bytes'], 9)
186
197
        self.assert_(not found1)
187
198
        self.assert_(found2)
188
199
 
189
200
 
190
201
if __name__ == '__main__':
191
 
    unittest.main()
 
202
    main()