def setUp(self): target_master = dict() target_other = dict() self.mock_master = ServersFacade(target_master) self.mock_other = ServersFacade(target_other) ServersFacade.use_persistence = False self.id_image1 = '0$image1' self.id_image2 = '0$image2' self.mock_master.add_image_to_mock([ 'Valladolid', 'image1', self.id_image1, 'active', '4984864768', 'c8982de656c0ca2c8b9fb7fdb0922bf4', '00000000000000000000000000000001', True, "{u'type': u'fiware:data', u'nid': u'855'}" ]) self.mock_master.add_image_to_mock([ 'Valladolid', 'image2', self.id_image2, 'active', '1', 'd9879de656c0ca2c8b9fb7fdb003bf5', '00000000000000000000000000000001', True, "{u'type': u'fiware:data', u'nid': u'300'}" ]) self.mock_master.add_emptyregion_to_mock('Burgos') self.mock_other.add_emptyregion_to_mock('other:Madrid') target_master['tenant'] = '00000000000000000000000000000001' target_other['tenant'] = '00000000000000000000000000000001' target_master['target_name'] = 'master' target_other['target_name'] = 'other' self.targets = {'master': target_master, 'other': target_other} self.region1 = GlanceSyncRegion('Valladolid', self.targets) self.region2 = GlanceSyncRegion('Burgos', self.targets) self.region3 = GlanceSyncRegion('other:Madrid', self.targets)
def setUp(self): """constructor""" self.master_region_dict = dict() self.images_region = list() target_master = {'tenant_id': 'VA_tenant1'} target_other = {'tenant_id': 'BU_tenant1'} self.targets = dict() self.targets['master'] = target_master self.targets['other'] = target_other target_other['metadata_set'] = set(['sync']) target_other['forcesyncs'] = list() self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('other:Burgos', self.targets)
def setUp(self): """create self.facade, create also a GlanceSyncImage object and a temporal file. Use a mock to replace osclients""" target = dict() target['target_name'] = 'master' target['user'] = '******' target['password'] = '******' target['keystone_url'] = 'http://127.0.0.1/' target['tenant'] = 'faketenant' target['use_keystone_v3'] = False self.target = target self.region = 'fakeregion' targets = dict() targets['master'] = target self.region_obj = GlanceSyncRegion(self.region, targets) mock_osclients.reset_mock() self.facade = ServersFacade(self.target) self.facade.images_dir = None image = GlanceSyncImage('imagetest', '01', self.region, None, False) image.raw = dict() image.raw['disk_format'] = 'qcow2' image.raw['is_public'] = False image.raw['protected'] = False image.raw['container_format'] = 'bare' image.raw['min_ram'] = '0' image.raw['min_disk'] = '0' self.image = image
def setUp(self): target = dict() target['target_name'] = 'master' target['user'] = env['OS_USERNAME'] target['password'] = env['OS_PASSWORD'] target['keystone_url'] = env['OS_AUTH_URL'] target['tenant'] = env['OS_TENANT_NAME'] target['use_keystone_v3'] = True if 'OS_REGION_NAME' in env: target['region'] = env['OS_REGION_NAME'] else: target['region'] = 'regionOne' self.region = target['region'] targets = dict() targets['master'] = target self.region_obj = GlanceSyncRegion(self.region, targets) self.created = None self.facade = ServersFacade(target) self.facade.images_dir = tempfile.mkdtemp(prefix='imagesdir_tmp') file_obj = open(self.facade.images_dir + '/01', 'w') file_obj.write('test content') file_obj.close() self.target = target _unset_environment()
def test_add_images_from_csv_to_mock(self): """test method add_images_from_cvs_to_mock. Check regions and images present""" tmp = get_path(os.path.abspath(os.curdir), RESOURCESPATH) path = os.path.join(tmp, 'basictest') ServersFacade.add_images_from_csv_to_mock(path) region = GlanceSyncRegion('other:Santander', self.targets) self.assertIn('Santander', self.mock_other.get_regions()) images = self.mock_other.get_imagelist(region) self.assertEquals(len(images), 2)
def setUp(self): self.targets = dict() target = dict() target['metadata_set'] = set() target['forcesyncs'] = set() target['metadata_condition'] = None target['only_tenant_images'] = False target['metadata_set'] = set() target['dontupdate'] = set() target['replace'] = set() target['rename'] = set() target['tenant_id'] = 'tenantid' # clone target2 = dict(target) self.targets['master'] = target self.targets['other'] = target2 self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('other:Madrid', self.targets)
def setUp(self): # Capture warnings logger = logging.getLogger('GlanceSync-Client') self.buffer_log = StringIO.StringIO() handler = logging.StreamHandler(self.buffer_log) logger.addHandler(handler) # Create master region dict self.master_region_dict = master_region_dict = dict() for i in range(11): image1 = self.create_image('Valladolid', i, '0') master_region_dict[image1.name] = image1 # Make particular cases in the images master_region_dict['image00'].is_public = False master_region_dict['image00'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['key1'] = 1000 master_region_dict['image02'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['key1'] = 2000 master_region_dict['image01'].user_properties['key2'] = 0 master_region_dict['image03'].user_properties['okhronisable'] = True master_region_dict['image03'].user_properties['kernel_id'] = 'image01' master_region_dict['image03'].user_properties['ramdisk_id'] = 'image02' master_region_dict['image04'].user_properties['okhronisable'] = True master_region_dict['image04'].user_properties['domain'] = 'acl3' master_region_dict['image05'].user_properties['okhronisable'] = True master_region_dict['image05'].user_properties['zone'] = 'acl4' master_region_dict['image06'].user_properties['p1'] = 30 master_region_dict['image06'].is_public = False master_region_dict['image07'].size = 100000 master_region_dict['image07'].user_properties['okhronisable'] = True master_region_dict['image07'].user_properties['p1'] = 40 master_region_dict['image08'].size = 5000 master_region_dict['image08'].user_properties['okhronisable'] = False master_region_dict['image09'].user_properties['okhronisable'] = True master_region_dict['image10'].is_public = False # Now, build the region dict using the same values self.region_dict = region_dict = dict() for i in range(11): image_master = master_region_dict['image' + str(i).zfill(2)] image_region = self.dup_image(image_master, 'Burgos', i, '1') region_dict[image_region.name] = image_region # Fix kernel_id and ramdisk_id of regional images region_dict['image03'].user_properties['kernel_id'] = '101' region_dict['image03'].user_properties['ramdisk_id'] = '102' region_dict['image09'].user_properties['ramdisk_id'] = '104' # changes some values in properties: the values included in meta_set # should affect, but not the others... region_dict['image01'].user_properties['key1'] = 1 region_dict['image02'].user_properties['key2'] = 1 self.targets = dict() target = dict() # in this case we use metadata_set as 'forbidden' properties target['metadata_set'] = set(['key1']) target['forcesyncs'] = set() cond = "image.user_properties.get('okhronisable',False) and\ not set(image.user_properties.keys()).intersection(set(['domain',\ 'zone'])) and image.size < 10000" target['metadata_condition'] = compile(cond, '', 'eval') target['only_tenant_images'] = False target['tenant_id'] = 'tenantid' target['dontupdate'] = set() target['replace'] = set() target['rename'] = set() self.targets['master'] = target self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('Burgos', self.targets) # Expected result of imges_to_sync_dict call self.expected_images_to_sync_dict = { 'image00': self.master_region_dict['image00'], 'image01': self.master_region_dict['image01'], 'image02': self.master_region_dict['image02'], 'image03': self.master_region_dict['image03'], 'image09': self.master_region_dict['image09'], }
class TestGlanceSyncRegion(unittest.TestCase): def create_image(self, region, count, prefix): """Helper function for creating a sequence or regions""" count = str(count).zfill(2) return GlanceSyncImage( 'image' + count, prefix + count, region, 'tenantid', True, 'checksum', 1000, 'active', dict()) def dup_image(self, image, region, count, prefix): """Helper function to create an image using another one, but for a different region""" count = str(count).zfill(2) new_image = copy.deepcopy(image) new_image.region = region new_image.id = prefix + count return new_image def assertNoWarnings(self): """Check that no warnings are generated by the test""" self.assertEquals(len(self.buffer_log.getvalue()), 0) def assertNumberWarnings(self, number): """Check that the number of warnings generated is the expected one""" self.assertEquals(len(self.buffer_log.getvalue().splitlines()), number) def setUp(self): # Capture warnings logger = logging.getLogger('GlanceSync-Client') self.buffer_log = StringIO.StringIO() handler = logging.StreamHandler(self.buffer_log) logger.addHandler(handler) # Create master region dict self.master_region_dict = master_region_dict = dict() for i in range(11): image1 = self.create_image('Valladolid', i, '0') master_region_dict[image1.name] = image1 # Make particular cases in the images master_region_dict['image00'].is_public = False master_region_dict['image00'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['key1'] = 1000 master_region_dict['image02'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['key1'] = 2000 master_region_dict['image01'].user_properties['key2'] = 0 master_region_dict['image03'].user_properties['okhronisable'] = True master_region_dict['image03'].user_properties['kernel_id'] = 'image01' master_region_dict['image03'].user_properties['ramdisk_id'] = 'image02' master_region_dict['image04'].user_properties['okhronisable'] = True master_region_dict['image04'].user_properties['domain'] = 'acl3' master_region_dict['image05'].user_properties['okhronisable'] = True master_region_dict['image05'].user_properties['zone'] = 'acl4' master_region_dict['image06'].user_properties['p1'] = 30 master_region_dict['image06'].is_public = False master_region_dict['image07'].size = 100000 master_region_dict['image07'].user_properties['okhronisable'] = True master_region_dict['image07'].user_properties['p1'] = 40 master_region_dict['image08'].size = 5000 master_region_dict['image08'].user_properties['okhronisable'] = False master_region_dict['image09'].user_properties['okhronisable'] = True master_region_dict['image10'].is_public = False # Now, build the region dict using the same values self.region_dict = region_dict = dict() for i in range(11): image_master = master_region_dict['image' + str(i).zfill(2)] image_region = self.dup_image(image_master, 'Burgos', i, '1') region_dict[image_region.name] = image_region # Fix kernel_id and ramdisk_id of regional images region_dict['image03'].user_properties['kernel_id'] = '101' region_dict['image03'].user_properties['ramdisk_id'] = '102' region_dict['image09'].user_properties['ramdisk_id'] = '104' # changes some values in properties: the values included in meta_set # should affect, but not the others... region_dict['image01'].user_properties['key1'] = 1 region_dict['image02'].user_properties['key2'] = 1 self.targets = dict() target = dict() # in this case we use metadata_set as 'forbidden' properties target['metadata_set'] = set(['key1']) target['forcesyncs'] = set() cond = "image.user_properties.get('okhronisable',False) and\ not set(image.user_properties.keys()).intersection(set(['domain',\ 'zone'])) and image.size < 10000" target['metadata_condition'] = compile(cond, '', 'eval') target['only_tenant_images'] = False target['tenant_id'] = 'tenantid' target['dontupdate'] = set() target['replace'] = set() target['rename'] = set() self.targets['master'] = target self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('Burgos', self.targets) # Expected result of imges_to_sync_dict call self.expected_images_to_sync_dict = { 'image00': self.master_region_dict['image00'], 'image01': self.master_region_dict['image01'], 'image02': self.master_region_dict['image02'], 'image03': self.master_region_dict['image03'], 'image09': self.master_region_dict['image09'], } def test_images_to_sync_dict_default(self): """test method images_to_sync_dict, without metadata_set nor metadata_condition""" self.targets['master']['metadata_set'] = set() self.targets['master']['metadata_condition'] = None new_dict = self.region.images_to_sync_dict(self.master_region_dict) expected = set(['image01', 'image02', 'image03', 'image04', 'image05', 'image07', 'image08', 'image09']) self.assertEquals(expected, set(new_dict.keys())) self.targets['master']['forcesyncs'] = set(['000', '010']) expected.add('image10') expected.add('image00') new_dict = self.region.images_to_sync_dict(self.master_region_dict) self.assertEquals(expected, set(new_dict.keys())) self.assertNoWarnings() def test_images_to_sync_dict_metadata(self): """test method images_to_sync_dict, without metadata_condition but with medata_set""" self.targets['master']['metadata_set'] = set(['p1']) self.targets['master']['metadata_condition'] = None new_dict = self.region.images_to_sync_dict(self.master_region_dict) expected = set(['image07']) self.assertEquals(expected, set(new_dict.keys())) self.assertNoWarnings() def test_images_to_sync_dict_func(self): """test method images_to_sync, with metadata_condition (see setUp)""" new_dict = self.region.images_to_sync_dict(self.master_region_dict) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(new_dict.keys())) self.assertNoWarnings() def test_local_images_filtered(self): """test method region_filtered""" region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, self.region_dict.values()) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNoWarnings() def test_local_images_filtered_owner(self): """Don't accept image if owner is not the tenant""" self.region_dict['image00'].owner = 'othertenantid' self.region.target['only_tenant_images'] = True region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, self.region_dict.values()) expected = set(['image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNumberWarnings(1) def test_local_images_filtered_owner_warning(self): """Accept image owned by another tenant, but check warning""" self.region_dict['image00'].owner = 'othertenantid' region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, self.region_dict.values()) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNumberWarnings(1) def test_local_images_filtered_duplicated(self): """Check warning because duplicated name""" region_list = self.region_dict.values() image_new = self.dup_image(self.region_dict['image00'], 'Burgos', 11, '0') region_list.append(image_new) region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, region_list) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNumberWarnings(1) def test_local_images_filtered_duplicated_checksum(self): """Check that if there is a duplicated name, but one of them has the right checksum, the image with the right checksum is used. This is independent of the warning""" region_list = self.region_dict.values() image_new_1 = self.dup_image(self.region_dict['image00'], 'Burgos', 11, '0') image_new_2 = self.dup_image(self.region_dict['image00'], 'Burgos', 12, '0') image_new_3 = self.dup_image(self.region_dict['image00'], 'Burgos', 13, '0') image_new_2.checksum = self.region_dict['image00'].checksum image_new_1.checksum = 'otherchecksum' image_new_3.checksum = 'otherchecksum' region_list = list() region_list.append(image_new_1) region_list.append(image_new_2) region_list.append(image_new_3) region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, region_list) images_ids = set(image.id for image in region_filtered.values()) self.assertIn('012', images_ids) self.assertNotIn('011', images_ids) self.assertNotIn('013', images_ids) self.assertNumberWarnings(2) def test_image_list_to_sync(self): """ This function involves calling both images_to_sync_dict and local_images_filtered and a pair of methods of GlanceSyncRegion; it is more an integration function. """ result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('pending_metadata', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_missing(self): """ Check with one image missing; this implies also metadata missing of image03, because its kernel_id points to the missing image. """ del(self.region_dict['image01']) result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('pending_upload', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_missing(self): """ Check with one image not active; this should be equivalent to a missing image, but also a warning is generated. """ self.region_dict['image01'].status = 'pending' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('pending_upload', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_error(self): """ Check with one image with different checksum """ self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('error_checksum', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_dont_update(self): """ Check with one image with different checksum, but included in dontupdate """ self.region.target['dontupdate'] = set(['otherchecksum']) self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('ok_stalled_checksum', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_replace(self): """ Check with one image with different checksum """ self.region.target['replace'] = set(['otherchecksum']) self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('pending_replace', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_rename(self): """ Check with one image with different checksum """ self.region.target['rename'] = set(['otherchecksum']) self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('pending_rename', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_mixed(self): """ Check with one image with different checksum """ self.region.target['dontupdate'] = set(['checksum1']) self.region.target['replace'] = set(['checksum2', 'any']) self.region.target['rename'] = set(['any']) self.region_dict['image01'].checksum = 'checksum1' self.region_dict['image00'].checksum = 'checksum2' self.region_dict['image03'].checksum = 'checksum3' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('pending_replace', self.region_dict['image00']), ('ok_stalled_checksum', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_rename', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_ami(self): """Check changing ramdisk_id of image03 to point to a wrong, but existing image and image09 to a image that is not in the synchronisation set""" self.region_dict['image03'].user_properties['ramdisk_id'] = '101' self.master_region_dict['image09'].user_properties['kernel_id'] =\ 'image04' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('ok', self.region_dict['image00']), ('pending_metadata', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_metadata', self.region_dict['image03']), ('error_ami', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_private(self): """Check image is_public differences between master and region""" self.master_region_dict['image00'].is_public = False self.region_dict['image00'].is_public = True self.master_region_dict['image01'].is_public = False self.region_dict['image01'].is_public = True result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [ ('pending_metadata', self.region_dict['image00']), ('pending_metadata', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list)
class TestGlanceSyncRegionObsoletedImages(unittest.TestCase): def _create_images(self, name): """Create a pair or images, one on each region""" image1 = GlanceSyncImage( name, 'id_VA_' + name, 'Valladolid', 'VA_tenant1', True, 'checksum', 1000, 'active', dict()) image1.is_public = False image2 = GlanceSyncImage( name, 'id_BU_' + name, 'Burgos', 'BU_tenant1', True, 'checksum', 1000, 'active', dict()) image2.is_public = False return image1, image2 def setUp(self): """constructor""" self.master_region_dict = dict() self.images_region = list() target_master = {'tenant_id': 'VA_tenant1'} target_other = {'tenant_id': 'BU_tenant1'} self.targets = dict() self.targets['master'] = target_master self.targets['other'] = target_other target_other['metadata_set'] = set(['sync']) target_other['forcesyncs'] = list() self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('other:Burgos', self.targets) def test_images_list_to_obsolete_notfound(self): """No images with _obsolete suffix in master""" (image1, image2) = self._create_images('image1') self.master_region_dict[image1.name] = image1 self.images_region.append(image2) (image1, image2) = self._create_images('image2') image2.name = 'image2_obsolete' self.master_region_dict[image1.name] = image2 result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_notfound_checksum(self): """Image found, but bad checksum""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.name = 'image1' image2.checksum = 'other_checksum' self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_notfound_checksum(self): """Image found, but bad owner""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.name = 'image1' image2.owner = 'other_owner' self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_found_alreadydone(self): """Found image obsolete, but already renamed and has the same meta """ (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_found_pending_rename(self): """Found image to rename""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.name = 'image1' self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertTrue(len(result) == 1) def test_images_list_to_obsolete_found_pending_public(self): """Found image already renamed, but public""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.is_public = True self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertTrue(len(result) == 1) self.assertFalse(result[0].is_public) def test_images_list_to_obsolete_found_pending_metadata(self): """Found image already renamed, but different metadata""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image1.user_properties['key1'] = 'value1' image2.user_properties['key1'] = 'value2' self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region, set(['key1'])) self.assertTrue(len(result) == 1) self.assertEquals(result[0].user_properties['key1'], 'value1') def test_images_list_to_obsolete_warning(self): """there is an image_obsoleted, but also exists image and it is synchronisable""" # Capture warnings logger = logging.getLogger('GlanceSync-Client') self.buffer_log = StringIO.StringIO() handler = logging.StreamHandler(self.buffer_log) handler.setLevel(logging.WARNING) logger.addHandler(handler) (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 (image1, image2) = self._create_images('image1') image1.user_properties['sync'] = True image1.is_public = True self.master_region_dict[image1.name] = image1 self.images_region.append(image2) result = self.region.image_list_to_obsolete( self.master_region_dict, self.images_region) self.assertFalse(result) msg = 'Ignore obsolete master image image1_obsolete because image1 '\ 'exists and it is synchronisable.' self.assertEquals(self.buffer_log.getvalue().strip(), msg)
class TestGlanceSyncRegion(unittest.TestCase): def create_image(self, region, count, prefix): """Helper function for creating a sequence or regions""" count = str(count).zfill(2) return GlanceSyncImage('image' + count, prefix + count, region, 'tenantid', True, 'checksum', 1000, 'active', dict()) def dup_image(self, image, region, count, prefix): """Helper function to create an image using another one, but for a different region""" count = str(count).zfill(2) new_image = copy.deepcopy(image) new_image.region = region new_image.id = prefix + count return new_image def assertNoWarnings(self): """Check that no warnings are generated by the test""" self.assertEquals(len(self.buffer_log.getvalue()), 0) def assertNumberWarnings(self, number): """Check that the number of warnings generated is the expected one""" self.assertEquals(len(self.buffer_log.getvalue().splitlines()), number) def setUp(self): # Capture warnings logger = logging.getLogger('GlanceSync-Client') self.buffer_log = StringIO.StringIO() handler = logging.StreamHandler(self.buffer_log) logger.addHandler(handler) # Create master region dict self.master_region_dict = master_region_dict = dict() for i in range(11): image1 = self.create_image('Valladolid', i, '0') master_region_dict[image1.name] = image1 # Make particular cases in the images master_region_dict['image00'].is_public = False master_region_dict['image00'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['key1'] = 1000 master_region_dict['image02'].user_properties['okhronisable'] = True master_region_dict['image01'].user_properties['key1'] = 2000 master_region_dict['image01'].user_properties['key2'] = 0 master_region_dict['image03'].user_properties['okhronisable'] = True master_region_dict['image03'].user_properties['kernel_id'] = 'image01' master_region_dict['image03'].user_properties['ramdisk_id'] = 'image02' master_region_dict['image04'].user_properties['okhronisable'] = True master_region_dict['image04'].user_properties['domain'] = 'acl3' master_region_dict['image05'].user_properties['okhronisable'] = True master_region_dict['image05'].user_properties['zone'] = 'acl4' master_region_dict['image06'].user_properties['p1'] = 30 master_region_dict['image06'].is_public = False master_region_dict['image07'].size = 100000 master_region_dict['image07'].user_properties['okhronisable'] = True master_region_dict['image07'].user_properties['p1'] = 40 master_region_dict['image08'].size = 5000 master_region_dict['image08'].user_properties['okhronisable'] = False master_region_dict['image09'].user_properties['okhronisable'] = True master_region_dict['image10'].is_public = False # Now, build the region dict using the same values self.region_dict = region_dict = dict() for i in range(11): image_master = master_region_dict['image' + str(i).zfill(2)] image_region = self.dup_image(image_master, 'Burgos', i, '1') region_dict[image_region.name] = image_region # Fix kernel_id and ramdisk_id of regional images region_dict['image03'].user_properties['kernel_id'] = '101' region_dict['image03'].user_properties['ramdisk_id'] = '102' region_dict['image09'].user_properties['ramdisk_id'] = '104' # changes some values in properties: the values included in meta_set # should affect, but not the others... region_dict['image01'].user_properties['key1'] = 1 region_dict['image02'].user_properties['key2'] = 1 self.targets = dict() target = dict() # in this case we use metadata_set as 'forbidden' properties target['metadata_set'] = set(['key1']) target['forcesyncs'] = set() cond = "image.user_properties.get('okhronisable',False) and\ not set(image.user_properties.keys()).intersection(set(['domain',\ 'zone'])) and image.size < 10000" target['metadata_condition'] = compile(cond, '', 'eval') target['only_tenant_images'] = False target['tenant_id'] = 'tenantid' target['dontupdate'] = set() target['replace'] = set() target['rename'] = set() self.targets['master'] = target self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('Burgos', self.targets) # Expected result of imges_to_sync_dict call self.expected_images_to_sync_dict = { 'image00': self.master_region_dict['image00'], 'image01': self.master_region_dict['image01'], 'image02': self.master_region_dict['image02'], 'image03': self.master_region_dict['image03'], 'image09': self.master_region_dict['image09'], } def test_images_to_sync_dict_default(self): """test method images_to_sync_dict, without metadata_set nor metadata_condition""" self.targets['master']['metadata_set'] = set() self.targets['master']['metadata_condition'] = None new_dict = self.region.images_to_sync_dict(self.master_region_dict) expected = set([ 'image01', 'image02', 'image03', 'image04', 'image05', 'image07', 'image08', 'image09' ]) self.assertEquals(expected, set(new_dict.keys())) self.targets['master']['forcesyncs'] = set(['000', '010']) expected.add('image10') expected.add('image00') new_dict = self.region.images_to_sync_dict(self.master_region_dict) self.assertEquals(expected, set(new_dict.keys())) self.assertNoWarnings() def test_images_to_sync_dict_metadata(self): """test method images_to_sync_dict, without metadata_condition but with medata_set""" self.targets['master']['metadata_set'] = set(['p1']) self.targets['master']['metadata_condition'] = None new_dict = self.region.images_to_sync_dict(self.master_region_dict) expected = set(['image07']) self.assertEquals(expected, set(new_dict.keys())) self.assertNoWarnings() def test_images_to_sync_dict_func(self): """test method images_to_sync, with metadata_condition (see setUp)""" new_dict = self.region.images_to_sync_dict(self.master_region_dict) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(new_dict.keys())) self.assertNoWarnings() def test_local_images_filtered(self): """test method region_filtered""" region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, self.region_dict.values()) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNoWarnings() def test_local_images_filtered_owner(self): """Don't accept image if owner is not the tenant""" self.region_dict['image00'].owner = 'othertenantid' self.region.target['only_tenant_images'] = True region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, self.region_dict.values()) expected = set(['image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNumberWarnings(1) def test_local_images_filtered_owner_warning(self): """Accept image owned by another tenant, but check warning""" self.region_dict['image00'].owner = 'othertenantid' region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, self.region_dict.values()) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNumberWarnings(1) def test_local_images_filtered_duplicated(self): """Check warning because duplicated name""" region_list = self.region_dict.values() image_new = self.dup_image(self.region_dict['image00'], 'Burgos', 11, '0') region_list.append(image_new) region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, region_list) expected = set(['image00', 'image01', 'image02', 'image03', 'image09']) self.assertEquals(expected, set(region_filtered.keys())) self.assertNumberWarnings(1) def test_local_images_filtered_duplicated_checksum(self): """Check that if there is a duplicated name, but one of them has the right checksum, the image with the right checksum is used. This is independent of the warning""" region_list = self.region_dict.values() image_new_1 = self.dup_image(self.region_dict['image00'], 'Burgos', 11, '0') image_new_2 = self.dup_image(self.region_dict['image00'], 'Burgos', 12, '0') image_new_3 = self.dup_image(self.region_dict['image00'], 'Burgos', 13, '0') image_new_2.checksum = self.region_dict['image00'].checksum image_new_1.checksum = 'otherchecksum' image_new_3.checksum = 'otherchecksum' region_list = list() region_list.append(image_new_1) region_list.append(image_new_2) region_list.append(image_new_3) region_filtered = self.region.local_images_filtered( self.expected_images_to_sync_dict, region_list) images_ids = set(image.id for image in region_filtered.values()) self.assertIn('012', images_ids) self.assertNotIn('011', images_ids) self.assertNotIn('013', images_ids) self.assertNumberWarnings(2) def test_image_list_to_sync(self): """ This function involves calling both images_to_sync_dict and local_images_filtered and a pair of methods of GlanceSyncRegion; it is more an integration function. """ result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('pending_metadata', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_missing(self): """ Check with one image missing; this implies also metadata missing of image03, because its kernel_id points to the missing image. """ del (self.region_dict['image01']) result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('pending_upload', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_missing(self): """ Check with one image not active; this should be equivalent to a missing image, but also a warning is generated. """ self.region_dict['image01'].status = 'pending' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('pending_upload', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_error(self): """ Check with one image with different checksum """ self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('error_checksum', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_dont_update(self): """ Check with one image with different checksum, but included in dontupdate """ self.region.target['dontupdate'] = set(['otherchecksum']) self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('ok_stalled_checksum', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_replace(self): """ Check with one image with different checksum """ self.region.target['replace'] = set(['otherchecksum']) self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('pending_replace', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_rename(self): """ Check with one image with different checksum """ self.region.target['rename'] = set(['otherchecksum']) self.region_dict['image01'].checksum = 'otherchecksum' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('pending_rename', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_ami', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_checksum_mixed(self): """ Check with one image with different checksum """ self.region.target['dontupdate'] = set(['checksum1']) self.region.target['replace'] = set(['checksum2', 'any']) self.region.target['rename'] = set(['any']) self.region_dict['image01'].checksum = 'checksum1' self.region_dict['image00'].checksum = 'checksum2' self.region_dict['image03'].checksum = 'checksum3' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('pending_replace', self.region_dict['image00']), ('ok_stalled_checksum', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_rename', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_ami(self): """Check changing ramdisk_id of image03 to point to a wrong, but existing image and image09 to a image that is not in the synchronisation set""" self.region_dict['image03'].user_properties['ramdisk_id'] = '101' self.master_region_dict['image09'].user_properties['kernel_id'] =\ 'image04' result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('ok', self.region_dict['image00']), ('pending_metadata', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('pending_metadata', self.region_dict['image03']), ('error_ami', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list) def test_image_list_to_sync_private(self): """Check image is_public differences between master and region""" self.master_region_dict['image00'].is_public = False self.region_dict['image00'].is_public = True self.master_region_dict['image01'].is_public = False self.region_dict['image01'].is_public = True result = self.region.image_list_to_sync(self.master_region_dict, self.region_dict.values()) expected = [('pending_metadata', self.region_dict['image00']), ('pending_metadata', self.region_dict['image01']), ('ok', self.region_dict['image02']), ('ok', self.region_dict['image03']), ('pending_metadata', self.region_dict['image09'])] result_as_list = list(x[1].name + '_' + x[0] for x in result) expected_as_list = list(x[1].name + '_' + x[0] for x in expected) self.assertEqual(expected_as_list, result_as_list)
class TestGlanceSyncRegionObsoletedImages(unittest.TestCase): def _create_images(self, name): """Create a pair or images, one on each region""" image1 = GlanceSyncImage(name, 'id_VA_' + name, 'Valladolid', 'VA_tenant1', True, 'checksum', 1000, 'active', dict()) image1.is_public = False image2 = GlanceSyncImage(name, 'id_BU_' + name, 'Burgos', 'BU_tenant1', True, 'checksum', 1000, 'active', dict()) image2.is_public = False return image1, image2 def setUp(self): """constructor""" self.master_region_dict = dict() self.images_region = list() target_master = {'tenant_id': 'VA_tenant1'} target_other = {'tenant_id': 'BU_tenant1'} self.targets = dict() self.targets['master'] = target_master self.targets['other'] = target_other target_other['metadata_set'] = set(['sync']) target_other['forcesyncs'] = list() self.master_region = GlanceSyncRegion('Valladolid', self.targets) self.region = GlanceSyncRegion('other:Burgos', self.targets) def test_images_list_to_obsolete_notfound(self): """No images with _obsolete suffix in master""" (image1, image2) = self._create_images('image1') self.master_region_dict[image1.name] = image1 self.images_region.append(image2) (image1, image2) = self._create_images('image2') image2.name = 'image2_obsolete' self.master_region_dict[image1.name] = image2 result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_notfound_checksum(self): """Image found, but bad checksum""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.name = 'image1' image2.checksum = 'other_checksum' self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_notfound_checksum(self): """Image found, but bad owner""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.name = 'image1' image2.owner = 'other_owner' self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_found_alreadydone(self): """Found image obsolete, but already renamed and has the same meta """ (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertFalse(result) def test_images_list_to_obsolete_found_pending_rename(self): """Found image to rename""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.name = 'image1' self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertTrue(len(result) == 1) def test_images_list_to_obsolete_found_pending_public(self): """Found image already renamed, but public""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image2.is_public = True self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertTrue(len(result) == 1) self.assertFalse(result[0].is_public) def test_images_list_to_obsolete_found_pending_metadata(self): """Found image already renamed, but different metadata""" (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 image1.user_properties['key1'] = 'value1' image2.user_properties['key1'] = 'value2' self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region, set(['key1'])) self.assertTrue(len(result) == 1) self.assertEquals(result[0].user_properties['key1'], 'value1') def test_images_list_to_obsolete_warning(self): """there is an image_obsoleted, but also exists image and it is synchronisable""" # Capture warnings logger = logging.getLogger('GlanceSync-Client') self.buffer_log = StringIO.StringIO() handler = logging.StreamHandler(self.buffer_log) handler.setLevel(logging.WARNING) logger.addHandler(handler) (image1, image2) = self._create_images('image1_obsolete') self.master_region_dict[image1.name] = image1 (image1, image2) = self._create_images('image1') image1.user_properties['sync'] = True image1.is_public = True self.master_region_dict[image1.name] = image1 self.images_region.append(image2) result = self.region.image_list_to_obsolete(self.master_region_dict, self.images_region) self.assertFalse(result) msg = 'Ignore obsolete master image image1_obsolete because image1 '\ 'exists and it is synchronisable.' self.assertEquals(self.buffer_log.getvalue().strip(), msg)