Beispiel #1
0
def get_metadata_async(service_id):
    """Returns service dynamic metadata.

  Raises:
    ServiceNotFoundError if service |service_id| is not found.
    DynamicMetadataError if metadata endpoint response is bad.
  """
    entity = yield storage.ServiceDynamicMetadata.get_by_id_async(service_id)
    if entity:
        msg = service_config_pb2.ServiceDynamicMetadata()
        if entity.metadata:
            msg.ParseFromString(entity.metadata)
        raise ndb.Return(msg)

    #TODO(myjang): delete the rest of the function once entities in production
    services = yield get_services_async()
    service = None
    for s in services:
        if s.id == service_id:
            service = s
    if service is None:
        raise ServiceNotFoundError('Service "%s" not found', service_id)

    if not service.metadata_url:
        raise ndb.Return(service_config_pb2.ServiceDynamicMetadata())
    try:
        res = yield net.json_request_async(service.metadata_url,
                                           scopes=net.EMAIL_SCOPE)
    except net.Error as ex:
        raise DynamicMetadataError('Net error: %s' % ex.message)
    msg = _dict_to_dynamic_metadata(res)
    raise ndb.Return(msg)
Beispiel #2
0
 def get_metadata_async(service_id):
   if service_id == 'a':
     raise ndb.Return(service_config_pb2.ServiceDynamicMetadata(
         validation=service_config_pb2.Validator(
             patterns=[service_config_pb2.ConfigPattern(
                 config_set='services/foo',
                 path='bar.cfg',
             )],
             url='https://bar.verifier',
         )
     ))
   if service_id == 'b':
     raise ndb.Return(service_config_pb2.ServiceDynamicMetadata(
         validation=service_config_pb2.Validator(
             patterns=[service_config_pb2.ConfigPattern(
                 config_set=r'regex:projects/[^/]+',
                 path=r'regex:.+\.cfg',
             )],
             url='https://bar2.verifier',
           )))
   if service_id == 'c':
     raise ndb.Return(service_config_pb2.ServiceDynamicMetadata(
         validation=service_config_pb2.Validator(
             patterns=[service_config_pb2.ConfigPattern(
                 config_set=r'regex:.+',
                 path=r'regex:.+',
             )],
             url='https://ultimate.verifier',
           )))
   return None
Beispiel #3
0
    def test_dict_to_dynamic_metadata(self):
        with self.assertRaises(services.DynamicMetadataError):
            services._dict_to_dynamic_metadata([])

        self.assertEqual(
            services._dict_to_dynamic_metadata({
                'version': '1.0',
                'validation': {
                    'url':
                    'https://a.com/validate',
                    'patterns': [
                        {
                            'config_set': 'projects/foo',
                            'path': 'bar.cfg'
                        },
                        {
                            'config_set': 'regex:services/.+',
                            'path': 'regex:.+'
                        },
                    ]
                }
            }),
            service_config_pb2.ServiceDynamicMetadata(
                validation=service_config_pb2.Validator(
                    url='https://a.com/validate',
                    patterns=[
                        service_config_pb2.ConfigPattern(
                            config_set='projects/foo', path='bar.cfg'),
                        service_config_pb2.ConfigPattern(
                            config_set='regex:services/.+', path='regex:.+'),
                    ])))
Beispiel #4
0
def get_metadata_async(service_id):
    """Returns service_config_pb2.ServiceDynamicMetadata for a service.

  Raises:
    DynamicMetadataError if metadata is not available or no such service.
  """
    entity = yield storage.ServiceDynamicMetadata.get_by_id_async(service_id)
    if not entity:
        raise DynamicMetadataError('No dynamic metadata for "%s"' % service_id)
    msg = service_config_pb2.ServiceDynamicMetadata()
    if entity.metadata:
        msg.ParseFromString(entity.metadata)
    raise ndb.Return(msg)
Beispiel #5
0
def _dict_to_dynamic_metadata(data):
    validation.validate_service_dynamic_metadata_blob(
        data,
        config.validation.Context.raise_on_error(
            exc_type=DynamicMetadataError))

    metadata = service_config_pb2.ServiceDynamicMetadata()
    validation_meta = data.get('validation')
    if validation_meta:
        metadata.validation.url = validation_meta['url']
        for p in validation_meta.get('patterns', []):
            pattern = metadata.validation.patterns.add()
            pattern.config_set = p['config_set']
            pattern.path = p['path']
    return metadata
Beispiel #6
0
    def test_get_metadata_async(self):
        self.mock(storage, 'get_self_config_async', mock.Mock())
        storage.get_self_config_async.return_value = future(
            service_config_pb2.ServicesCfg(services=[
                service_config_pb2.Service(
                    id='foo', metadata_url='https://foo.com/metadata')
            ]))

        self.mock(net, 'json_request_async', mock.Mock())
        net.json_request_async.return_value = future({
            'version': '1.0',
            'validation': {
                'url':
                'https://a.com/validate',
                'patterns': [
                    {
                        'config_set': 'projects/foo',
                        'path': 'bar.cfg'
                    },
                    {
                        'config_set': 'regex:services/.+',
                        'path': 'regex:.+'
                    },
                ]
            }
        })

        metadata = services.get_metadata_async('foo').get_result()
        self.assertEqual(
            metadata,
            service_config_pb2.ServiceDynamicMetadata(
                validation=service_config_pb2.Validator(
                    url='https://a.com/validate',
                    patterns=[
                        service_config_pb2.ConfigPattern(
                            config_set='projects/foo', path='bar.cfg'),
                        service_config_pb2.ConfigPattern(
                            config_set='regex:services/.+', path='regex:.+'),
                    ])))

        net.json_request_async.assert_called_once_with(
            'https://foo.com/metadata', scopes=net.EMAIL_SCOPE)

        storage.get_self_config_async.assert_called_once_with(
            common.SERVICES_REGISTRY_FILENAME, service_config_pb2.ServicesCfg)
Beispiel #7
0
def get_metadata_async(service_id):
    """Returns service dynamic metadata.

  Memcaches results for 1 min. Never returns None.

  Raises:
    ServiceNotFoundError if service |service_id| is not found.
    DynamicMetadataError if metadata endpoint response is bad.
  """
    service = yield get_service_async(service_id)
    if service is None:
        raise ServiceNotFoundError('Service "%s" not found', service_id)

    if not service.metadata_url:
        raise ndb.Return(service_config_pb2.ServiceDynamicMetadata())

    try:
        res = yield net.json_request_async(service.metadata_url,
                                           scopes=net.EMAIL_SCOPE)
    except net.Error as ex:
        raise DynamicMetadataError('Net error: %s' % ex.message)
    raise ndb.Return(_dict_to_dynamic_metadata(res))