def test_extra(self): """Extra IP addresses are treated the same.""" ip_set = generate_ip_set((), ("1.2.3.4", )) self.assertEqual(len(ip_set.iter_cidrs()), 4) ip_set = generate_ip_set(("1.1.1.1", ), ("1.2.3.4", )) self.assertEqual(len(ip_set.iter_cidrs()), 8) # They can duplicate without error. ip_set = generate_ip_set(("1.2.3.4", ), ("1.2.3.4", )) self.assertEqual(len(ip_set.iter_cidrs()), 4)
def test_generate(self): """Check adding IPv4 and IPv6 addresses.""" # IPv4 address ip_set = generate_ip_set(("1.2.3.4", )) self.assertEqual(len(ip_set.iter_cidrs()), 4) # IPv4 CIDR ip_set = generate_ip_set(("1.2.3.4/24", )) self.assertEqual(len(ip_set.iter_cidrs()), 4) # IPv6 address ip_set = generate_ip_set(("2001:db8::8a2e:370:7334", )) self.assertEqual(len(ip_set.iter_cidrs()), 1) # IPv6 CIDR ip_set = generate_ip_set(("2001:db8::/104", )) self.assertEqual(len(ip_set.iter_cidrs()), 1) # The addresses can overlap OK. ip_set = generate_ip_set(("1.2.3.4", "::1.2.3.4")) self.assertEqual(len(ip_set.iter_cidrs()), 4)
def test_bad_value(self): """An error should be raised if a bad value is passed in.""" with self.assertRaises(ConfigError): generate_ip_set(("not-an-ip", )) with self.assertRaises(ConfigError): generate_ip_set(("1.2.3.4/128", )) with self.assertRaises(ConfigError): generate_ip_set((":::", )) # The following get treated as empty data. self.assertFalse(generate_ip_set(None)) self.assertFalse(generate_ip_set({}))
def read_config(self, config, **kwargs): # Only enable the media repo if either the media repo is enabled or the # current worker app is the media repo. if (self.enable_media_repo is False and config.get("worker_app") != "synapse.app.media_repository"): self.can_load_media_repo = False return else: self.can_load_media_repo = True # Whether this instance should be the one to run the background jobs to # e.g clean up old URL previews. self.media_instance_running_background_jobs = config.get( "media_instance_running_background_jobs", ) self.max_upload_size = self.parse_size( config.get("max_upload_size", "50M")) self.max_image_pixels = self.parse_size( config.get("max_image_pixels", "32M")) self.max_spider_size = self.parse_size( config.get("max_spider_size", "10M")) self.media_store_path = self.ensure_directory( config.get("media_store_path", "media_store")) backup_media_store_path = config.get("backup_media_store_path") synchronous_backup_media_store = config.get( "synchronous_backup_media_store", False) storage_providers = config.get("media_storage_providers", []) if backup_media_store_path: if storage_providers: raise ConfigError( "Cannot use both 'backup_media_store_path' and 'storage_providers'" ) storage_providers = [{ "module": "file_system", "store_local": True, "store_synchronous": synchronous_backup_media_store, "store_remote": True, "config": { "directory": backup_media_store_path }, }] # This is a list of config that can be used to create the storage # providers. The entries are tuples of (Class, class_config, # MediaStorageProviderConfig), where Class is the class of the provider, # the class_config the config to pass to it, and # MediaStorageProviderConfig are options for StorageProviderWrapper. # # We don't create the storage providers here as not all workers need # them to be started. self.media_storage_providers = [] # type: List[tuple] for i, provider_config in enumerate(storage_providers): # We special case the module "file_system" so as not to need to # expose FileStorageProviderBackend if provider_config["module"] == "file_system": provider_config["module"] = ( "synapse.rest.media.v1.storage_provider" ".FileStorageProviderBackend") provider_class, parsed_config = load_module( provider_config, ("media_storage_providers", "<item %i>" % i)) wrapper_config = MediaStorageProviderConfig( provider_config.get("store_local", False), provider_config.get("store_remote", False), provider_config.get("store_synchronous", False), ) self.media_storage_providers.append( (provider_class, parsed_config, wrapper_config)) self.dynamic_thumbnails = config.get("dynamic_thumbnails", False) self.thumbnail_requirements = parse_thumbnail_requirements( config.get("thumbnail_sizes", DEFAULT_THUMBNAIL_SIZES)) self.url_preview_enabled = config.get("url_preview_enabled", False) if self.url_preview_enabled: try: check_requirements("url_preview") except DependencyException as e: raise ConfigError(e.message) if "url_preview_ip_range_blacklist" not in config: raise ConfigError( "For security, you must specify an explicit target IP address " "blacklist in url_preview_ip_range_blacklist for url previewing " "to work") # we always blacklist '0.0.0.0' and '::', which are supposed to be # unroutable addresses. self.url_preview_ip_range_blacklist = generate_ip_set( config["url_preview_ip_range_blacklist"], ["0.0.0.0", "::"], config_path=("url_preview_ip_range_blacklist", ), ) self.url_preview_ip_range_whitelist = generate_ip_set( config.get("url_preview_ip_range_whitelist", ()), config_path=("url_preview_ip_range_whitelist", ), ) self.url_preview_url_blacklist = config.get( "url_preview_url_blacklist", ()) self.url_preview_accept_language = config.get( "url_preview_accept_language") or ["en"]
def test_empty(self): ip_set = generate_ip_set(()) self.assertFalse(ip_set) ip_set = generate_ip_set((), ()) self.assertFalse(ip_set)