Ejemplo n.º 1
0
    def test_bad_object_in_array(self):
        """malformed objects within an array should be validated correctly"""

        # consider a structure:
        #
        # array_of_objs:
        #   - r: 1
        #     foo: 2
        #
        #   - r: 2
        #     bar: 3
        #
        # ... where each entry must contain an "r": check that the path
        # to the required item is correclty reported.

        schema = {
            "type": "object",
            "properties": {
                "array_of_objs": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "required": ["r"]
                    },
                },
            },
        }

        with self.assertRaises(ConfigError) as c:
            validate_config(schema, {"array_of_objs": [{}]}, ("base", ))

        self.assertEqual(c.exception.path,
                         ["base", "array_of_objs", "<item 0>"])
Ejemplo n.º 2
0
def _parse_oidc_provider_configs(
        config: JsonDict) -> Iterable["OidcProviderConfig"]:
    """extract and parse the OIDC provider configs from the config dict

    The configuration may contain either a single `oidc_config` object with an
    `enabled: True` property, or a list of provider configurations under
    `oidc_providers`, *or both*.

    Returns a generator which yields the OidcProviderConfig objects
    """
    validate_config(MAIN_CONFIG_SCHEMA, config, ())

    for i, p in enumerate(config.get("oidc_providers") or []):
        yield _parse_oidc_config_dict(p,
                                      ("oidc_providers", "<item %i>" % (i, )))

    # for backwards-compatibility, it is also possible to provide a single "oidc_config"
    # object with an "enabled: True" property.
    oidc_config = config.get("oidc_config")
    if oidc_config and oidc_config.get("enabled", False):
        # MAIN_CONFIG_SCHEMA checks that `oidc_config` is an object, but not that
        # it matches OIDC_PROVIDER_CONFIG_SCHEMA (see the comments on OIDC_CONFIG_SCHEMA
        # above), so now we need to validate it.
        validate_config(OIDC_PROVIDER_CONFIG_SCHEMA, oidc_config,
                        ("oidc_config", ))
        yield _parse_oidc_config_dict(oidc_config, ("oidc_config", ))
Ejemplo n.º 3
0
    def read_config(self, config, **kwargs):
        # FIXME: federation_domain_whitelist needs sytests
        self.federation_domain_whitelist: Optional[dict] = None
        federation_domain_whitelist = config.get("federation_domain_whitelist",
                                                 None)

        if federation_domain_whitelist is not None:
            # turn the whitelist into a hash for speed of lookup
            self.federation_domain_whitelist = {}

            for domain in federation_domain_whitelist:
                self.federation_domain_whitelist[domain] = True

        federation_metrics_domains = config.get(
            "federation_metrics_domains") or []
        validate_config(
            _METRICS_FOR_DOMAINS_SCHEMA,
            federation_metrics_domains,
            ("federation_metrics_domains", ),
        )
        self.federation_metrics_domains = set(federation_metrics_domains)

        self.allow_profile_lookup_over_federation = config.get(
            "allow_profile_lookup_over_federation", True)

        self.allow_device_name_lookup_over_federation = config.get(
            "allow_device_name_lookup_over_federation", True)
Ejemplo n.º 4
0
    def read_config(self, config, **kwargs):
        # FIXME: federation_domain_whitelist needs sytests
        self.federation_domain_whitelist = None  # type: Optional[dict]
        federation_domain_whitelist = config.get("federation_domain_whitelist",
                                                 None)

        if federation_domain_whitelist is not None:
            # turn the whitelist into a hash for speed of lookup
            self.federation_domain_whitelist = {}

            for domain in federation_domain_whitelist:
                self.federation_domain_whitelist[domain] = True

        self.federation_ip_range_blacklist = config.get(
            "federation_ip_range_blacklist", [])

        # Attempt to create an IPSet from the given ranges
        try:
            self.federation_ip_range_blacklist = IPSet(
                self.federation_ip_range_blacklist)

            # Always blacklist 0.0.0.0, ::
            self.federation_ip_range_blacklist.update(["0.0.0.0", "::"])
        except Exception as e:
            raise ConfigError(
                "Invalid range(s) provided in federation_ip_range_blacklist: %s"
                % e)

        federation_metrics_domains = config.get(
            "federation_metrics_domains") or []
        validate_config(
            _METRICS_FOR_DOMAINS_SCHEMA,
            federation_metrics_domains,
            ("federation_metrics_domains", ),
        )
        self.federation_metrics_domains = set(federation_metrics_domains)
Ejemplo n.º 5
0
 def read_config(self, config: JsonDict, **kwargs: Any) -> None:
     validate_config(_MAIN_SCHEMA, config, ())
     self.room_prejoin_state = list(self._get_prejoin_state_types(config))
     self.track_puppeted_user_ips = config.get("track_puppeted_user_ips", False)
Ejemplo n.º 6
0
Archivo: api.py Proyecto: ulope/synapse
 def read_config(self, config: JsonDict, **kwargs):
     validate_config(_MAIN_SCHEMA, config, ())
     self.room_prejoin_state = list(self._get_prejoin_state_types(config))