Source Code for Module pike.test.appinstanceid

  1  # 
  2  # Copyright (c) 2013, EMC Corporation 
  3  # All rights reserved. 
  4  # 
  5  # Redistribution and use in source and binary forms, with or without 
  6  # modification, are permitted provided that the following conditions are met: 
  7  # 
  8  # 1. Redistributions of source code must retain the above copyright notice, 
  9  # this list of conditions and the following disclaimer. 
 10  # 2. Redistributions in binary form must reproduce the above copyright notice, 
 11  # this list of conditions and the following disclaimer in the documentation 
 12  # and/or other materials provided with the distribution. 
 13  # 
 14  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 15  # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 16  # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 17  # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
 18  # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 19  # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 20  # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 21  # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 22  # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 23  # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 24  # POSSIBILITY OF SUCH DAMAGE. 
 25  # 
 26  # Module Name: 
 27  # 
 28  #        appinstanceid.py 
 29  # 
 30  # Abstract: 
 31  # 
 32  #        App instance ID tests 
 33  # 
 34  # Authors: Arlene Berry (arlene.berry@emc.com) 
 35  # 
 36   
 37  import pike.model 
 38  import pike.smb2 
 39  import pike.test 
 40  import pike.ntstatus 
 41  import random 
 42  import array 
 43   
 44  @pike.test.RequireDialect(pike.smb2.DIALECT_SMB3_0) 
 45  @pike.test.RequireCapabilities(pike.smb2.SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) 
 46  @pike.test.RequireShareCapabilities(pike.smb2.SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY) 
 47 -class AppInstanceIdTest(pike.test.PikeTest): 
 48 -    def __init__(self, *args, **kwargs): 
 49          super(AppInstanceIdTest, self).__init__(*args, **kwargs) 
 50          self.share_all = pike.smb2.FILE_SHARE_READ | pike.smb2.FILE_SHARE_WRITE | pike.smb2.FILE_SHARE_DELETE 
 51          self.lease1 = array.array('B',map(random.randint, [0]*16, [255]*16)) 
 52          self.app_instance_id1 = array.array('B',map(random.randint, [0]*16, [255]*16)) 
 53          self.r = pike.smb2.SMB2_LEASE_READ_CACHING 
 54          self.rw = self.r | pike.smb2.SMB2_LEASE_WRITE_CACHING 
 55          self.rh = self.r | pike.smb2.SMB2_LEASE_HANDLE_CACHING 
 56          self.rwh = self.rw | self.rh 
 57   
 58      # Perform create with AppInstanceId 
 59 -    def test_appinstanceid(self): 
 60          chan, tree = self.tree_connect() 
 61           
 62          # Request rwh lease 
 63          handle1 = chan.create(tree, 
 64                                'appinstanceid.txt', 
 65                                access=pike.smb2.FILE_READ_DATA | pike.smb2.FILE_WRITE_DATA | pike.smb2.DELETE, 
 66                                share=self.share_all, 
 67                                disposition=pike.smb2.FILE_OPEN_IF, 
 68                                options=pike.smb2.FILE_DELETE_ON_CLOSE, 
 69                                oplock_level=pike.smb2.SMB2_OPLOCK_LEVEL_LEASE, 
 70                                lease_key = self.lease1, 
 71                                lease_state = self.rwh, 
 72                                durable=0, 
 73                                persistent=True, 
 74                                app_instance_id=self.app_instance_id1).result() 
 75       
 76          self.assertEqual(handle1.durable_flags, pike.smb2.SMB2_DHANDLE_FLAG_PERSISTENT) 
 77          self.assertEqual(handle1.lease.lease_state, self.rwh) 
 78   
 79          chan.close(handle1) 
 80           
 81      # Invalidate disconnected persistent handle via AppInstanceId 
 82 -    def test_appinstanceid_persistent_with_disconnect(self): 
 83          chan, tree = self.tree_connect() 
 84   
 85          # Request rwh lease 
 86          handle1 = chan.create(tree, 
 87                                'appinstanceid.txt', 
 88                                share=self.share_all, 
 89                                disposition=pike.smb2.FILE_OPEN_IF, 
 90                                oplock_level=pike.smb2.SMB2_OPLOCK_LEVEL_LEASE, 
 91                                lease_key = self.lease1, 
 92                                lease_state = self.rwh, 
 93                                durable=0, 
 94                                persistent=True, 
 95                                app_instance_id=self.app_instance_id1).result() 
 96   
 97          self.assertEqual(handle1.durable_flags, pike.smb2.SMB2_DHANDLE_FLAG_PERSISTENT) 
 98          self.assertEqual(handle1.lease.lease_state, self.rwh) 
 99   
100          # Close the connection 
101          chan.connection.close() 
102   
103          chan2, tree2 = self.tree_connect(client=pike.model.Client()) 
104   
105          # Request reconnect 
106          handle2 = chan2.create(tree, 
107                                 'appinstanceid.txt', 
108                                 access=pike.smb2.FILE_READ_DATA | pike.smb2.FILE_WRITE_DATA | pike.smb2.DELETE, 
109                                 share=self.share_all, 
110                                 disposition=pike.smb2.FILE_OPEN_IF, 
111                                 options=pike.smb2.FILE_DELETE_ON_CLOSE, 
112                                 oplock_level=pike.smb2.SMB2_OPLOCK_LEVEL_LEASE, 
113                                 lease_key = self.lease1, 
114                                 lease_state = self.rwh, 
115                                 durable=0, 
116                                 persistent=True, 
117                                 app_instance_id=self.app_instance_id1).result() 
118       
119          self.assertEqual(handle2.durable_flags, pike.smb2.SMB2_DHANDLE_FLAG_PERSISTENT) 
120          self.assertEqual(handle2.lease.lease_state, self.rwh) 
121   
122          chan2.close(handle2) 
123   
124      # Invalidating a disconnected persistent handle 
125      # with AppInstanceId fails when reusing the same client GUID 
126 -    def test_appinstanceid_reconnect_same_clientguid(self): 
127          chan, tree = self.tree_connect() 
128   
129          # Request rwh lease 
130          handle1 = chan.create(tree, 
131                                'appinstanceid.txt', 
132                                share=self.share_all, 
133                                disposition=pike.smb2.FILE_OPEN_IF, 
134                                oplock_level=pike.smb2.SMB2_OPLOCK_LEVEL_LEASE, 
135                                lease_key = self.lease1, 
136                                lease_state = self.rwh, 
137                                durable=0, 
138                                persistent=True, 
139                                app_instance_id=self.app_instance_id1).result() 
140   
141          self.assertEqual(handle1.durable_flags, pike.smb2.SMB2_DHANDLE_FLAG_PERSISTENT) 
142          self.assertEqual(handle1.lease.lease_state, self.rwh) 
143   
144          # Close the connection 
145          chan.connection.close() 
146   
147          chan2, tree2 = self.tree_connect() 
148   
149          # Request reconnect 
150          with self.assert_error(pike.ntstatus.STATUS_FILE_NOT_AVAILABLE): 
151              handle2 = chan2.create(tree, 
152                                 'appinstanceid.txt', 
153                                 access=pike.smb2.FILE_READ_DATA | pike.smb2.FILE_WRITE_DATA | pike.smb2.DELETE, 
154                                 share=self.share_all, 
155                                 disposition=pike.smb2.FILE_OPEN_IF, 
156                                 options=pike.smb2.FILE_DELETE_ON_CLOSE, 
157                                 oplock_level=pike.smb2.SMB2_OPLOCK_LEVEL_LEASE, 
158                                 lease_key = self.lease1, 
159                                 lease_state = self.rwh, 
160                                 durable=0, 
161                                 persistent=True, 
162                                 app_instance_id=self.app_instance_id1).result() 
163   
164          # Close the connection 
165          chan2.connection.close() 
166   
167          chan3, tree3 = self.tree_connect(client=pike.model.Client()) 
168   
169          # Request reconnect 
170          handle3 = chan3.create(tree, 
171                                 'appinstanceid.txt', 
172                                 access=pike.smb2.FILE_READ_DATA | pike.smb2.FILE_WRITE_DATA | pike.smb2.DELETE, 
173                                 share=self.share_all, 
174                                 disposition=pike.smb2.FILE_OPEN_IF, 
175                                 options=pike.smb2.FILE_DELETE_ON_CLOSE, 
176                                 oplock_level=pike.smb2.SMB2_OPLOCK_LEVEL_LEASE, 
177                                 lease_key = self.lease1, 
178                                 lease_state = self.rwh, 
179                                 durable=0, 
180                                 persistent=True, 
181                                 app_instance_id=self.app_instance_id1).result() 
182       
183          self.assertEqual(handle3.durable_flags, pike.smb2.SMB2_DHANDLE_FLAG_PERSISTENT) 
184          self.assertEqual(handle3.lease.lease_state, self.rwh) 
185   
186          chan3.close(handle3) 
187