示例#1
0
  def _ReadHandshakeResponse(self, decoder):
    """Reads and processes the handshake response message.

    Args:
      decoder: Decoder to read messages from.
    Returns:
      call-response exists (boolean) ???
    Raises:
      schema.AvroException on ???
    """
    handshake_response = HANDSHAKE_REQUESTOR_READER.read(decoder)
    logger.info('Processing handshake response: %s', handshake_response)
    match = handshake_response['match']
    if match == 'BOTH':
      # Both client and server protocol hashes match:
      self._send_protocol = False
      return True

    elif match == 'CLIENT':
      # Client's side hash mismatch:
      self._remote_protocol = \
          protocol.parse(handshake_response['serverProtocol'])
      self._remote_hash = handshake_response['serverHash']
      self._send_protocol = False
      return True

    elif match == 'NONE':
      # Neither client nor server match:
      self._remote_protocol = \
          protocol.parse(handshake_response['serverProtocol'])
      self._remote_hash = handshake_response['serverHash']
      self._send_protocol = True
      return False
    else:
      raise schema.AvroException('handshake_response.match=%r' % match)
示例#2
0
  def test_valid_cast_to_string_after_parse(self):
    """
    Test that the string generated by an Avro Protocol object
    is, in fact, a valid Avro protocol.
    """
    print('')
    print('TEST CAST TO STRING')
    print('===================')
    print('')

    num_correct = 0
    for example in VALID_EXAMPLES:
      protocol_data = protocol.parse(example.protocol_string)
      try:
        protocol.parse(str(protocol_data))
      except (ValueError, ProtocolParseException):
        debug_msg = "%s: STRING CAST FAILURE" % example.name
      else:
        debug_msg = "%s: STRING CAST SUCCESS" % example.name
        num_correct += 1
      print(debug_msg)

    fail_msg = "Cast to string success on %d out of %d protocols" % \
      (num_correct, len(VALID_EXAMPLES))
    self.assertEqual(num_correct, len(VALID_EXAMPLES), fail_msg)
示例#3
0
  def test_equivalence_after_round_trip(self):
    """
    1. Given a string, parse it to get Avro protocol "original".
    2. Serialize "original" to a string and parse that string
         to generate Avro protocol "round trip".
    3. Ensure "original" and "round trip" protocols are equivalent.
    """
    print('')
    print('TEST ROUND TRIP')
    print('===============')
    print('')

    num_correct = 0
    for example in VALID_EXAMPLES:
      original_protocol = protocol.parse(example.protocol_string)
      round_trip_protocol = protocol.parse(str(original_protocol))

      if original_protocol == round_trip_protocol:
        num_correct += 1
        debug_msg = "%s: ROUND TRIP SUCCESS" % example.name
      else:
        self.fail("Round trip failure: %s %s %s", (example.name, example.protocol_string, str(original_protocol)))

    fail_msg = "Round trip success on %d out of %d protocols" % \
      (num_correct, len(VALID_EXAMPLES))
    self.assertEqual(num_correct, len(VALID_EXAMPLES), fail_msg)
示例#4
0
文件: ipc.py 项目: davnoe/kiji
    def _read_handshake_response(self, decoder):
        """Reads and processes the handshake response message.

        Args:
            decoder: Decoder to read messages from.
        Returns:
            call-response exists (boolean) ???
        Raises:
            schema.AvroException on ???
        """
        handshake_response = HANDSHAKE_REQUESTOR_READER.read(decoder)
        logging.debug("Processing handshake response: %s", handshake_response)
        match = handshake_response["match"]
        if match == "BOTH":
            # Both client and server protocol hashes match:
            self._send_protocol = False
            return True

        elif match == "CLIENT":
            # Client side hash mismatch:
            self._remote_protocol = protocol.parse(handshake_response["serverProtocol"])
            self._remote_hash = handshake_response["serverHash"]
            self._send_protocol = False
            return True

        elif match == "NONE":
            # Neither client nor server match:
            self._remote_protocol = protocol.parse(handshake_response["serverProtocol"])
            self._remote_hash = handshake_response["serverHash"]
            self._send_protocol = True
            return False
        else:
            raise schema.AvroException("handshake_response.match=%r" % match)
示例#5
0
    def testEquivalenceAfterRoundTrip(self):
        """
        1. Given a string, parse it to get Avro protocol "original".
        2. Serialize "original" to a string and parse that string
         to generate Avro protocol "round trip".
        3. Ensure "original" and "round trip" protocols are equivalent.
        """
        num_correct = 0
        for example in VALID_EXAMPLES:
            original_protocol = protocol.parse(example.protocol_string)
            round_trip_protocol = protocol.parse(str(original_protocol))

            if original_protocol == round_trip_protocol:
                num_correct += 1
                logging.debug('Successful round-trip for protocol:\n%s',
                              example.protocol_string)
            else:
                self.fail(
                    'Round-trip failure for protocol:\n%s\nOriginal protocol:\n%s'
                    % (example.protocol_string, str(original_protocol)))

        self.assertEqual(
            num_correct, len(VALID_EXAMPLES),
            'Round trip success on %d out of %d protocols.' %
            (num_correct, len(VALID_EXAMPLES)))
示例#6
0
    def _read_handshake_response(self, decoder):
        """Reads and processes the handshake response message.

        Args:
            decoder: Decoder to read messages from.
        Returns:
            call-response exists (boolean) ???
        Raises:
            schema.AvroException on ???
        """
        handshake_response = HANDSHAKE_REQUESTOR_READER.read(decoder)
        logging.debug("Processing handshake response: %s", handshake_response)
        match = handshake_response["match"]
        if match == "BOTH":
            # Both client and server protocol hashes match:
            self._send_protocol = False
            return True

        elif match == "CLIENT":
            # Client side hash mismatch:
            self._remote_protocol = protocol.parse(
                handshake_response["serverProtocol"])
            self._remote_hash = handshake_response["serverHash"]
            self._send_protocol = False
            return True

        elif match == "NONE":
            # Neither client nor server match:
            self._remote_protocol = protocol.parse(
                handshake_response["serverProtocol"])
            self._remote_hash = handshake_response["serverHash"]
            self._send_protocol = True
            return False
        else:
            raise schema.AvroException("handshake_response.match=%r" % match)
示例#7
0
  def test_equivalence_after_round_trip(self):
    """
    1. Given a string, parse it to get Avro protocol "original".
    2. Serialize "original" to a string and parse that string
         to generate Avro protocol "round trip".
    3. Ensure "original" and "round trip" protocols are equivalent.
    """
    print ''
    print 'TEST ROUND TRIP'
    print '==============='
    print ''

    num_correct = 0
    for example in VALID_EXAMPLES:
      original_protocol = protocol.parse(example.protocol_string)
      round_trip_protocol = protocol.parse(str(original_protocol))

      if original_protocol == round_trip_protocol:
        num_correct += 1
        debug_msg = "%s: ROUND TRIP SUCCESS" % example.name
      else:       
        self.fail("Round trip failure: %s %s %s", (example.name, example.protocol_string, str(original_protocol)))

    fail_msg = "Round trip success on %d out of %d protocols" % \
      (num_correct, len(VALID_EXAMPLES))
    self.assertEqual(num_correct, len(VALID_EXAMPLES), fail_msg)
示例#8
0
  def test_valid_cast_to_string_after_parse(self):
    """
    Test that the string generated by an Avro Protocol object
    is, in fact, a valid Avro protocol.
    """
    print ''
    print 'TEST CAST TO STRING'
    print '==================='
    print ''

    num_correct = 0
    for example in VALID_EXAMPLES:
      protocol_data = protocol.parse(example.protocol_string)
      try:
        try:
          protocol.parse(str(protocol_data))
          debug_msg = "%s: STRING CAST SUCCESS" % example.name
          num_correct += 1
        except:
          debug_msg = "%s: STRING CAST FAILURE" % example.name
      finally:
        print debug_msg

    fail_msg = "Cast to string success on %d out of %d protocols" % \
      (num_correct, len(VALID_EXAMPLES))
    self.assertEqual(num_correct, len(VALID_EXAMPLES), fail_msg)
示例#9
0
 def test_parse(self):
   num_correct = 0
   for example in EXAMPLES:
     try:
       protocol.parse(example.protocol_string)
       if example.valid: 
         num_correct += 1
       else:
         self.fail("Parsed invalid protocol: %s" % (example.name,))
     except Exception, e:
       if not example.valid: 
         num_correct += 1
       else:
         self.fail("Coudl not parse valid protocol: %s" % (example.name,))
示例#10
0
    def testParse(self):
        correct = 0
        for iexample, example in enumerate(EXAMPLES):
            logging.debug('Parsing protocol #%d:\n%s', iexample, example.protocol_string)
            try:
                parsed = protocol.parse(example.protocol_string)
                if example.valid:
                    correct += 1
                else:
                    self.fail('Invalid protocol was parsed:\n%s' % example.protocol_string)
            except Exception as exn:
                if example.valid:
                    self.fail('Valid protocol failed to parse: %s\n%s'
                              % (example.protocol_string, traceback.format_exc()))
                else:
                    if logging.getLogger().getEffectiveLevel() <= 5:
                        logging.debug('Expected error:\n%s', traceback.format_exc())
                    else:
                        logging.debug('Expected error: %r', exn)
                    correct += 1

        self.assertEqual(
            correct,
            len(EXAMPLES),
            'Parse behavior correct on %d out of %d protocols.'
            % (correct, len(EXAMPLES)))
示例#11
0
文件: ipc.py 项目: AlexChen12/avro
  def process_handshake(self, decoder, encoder):
    handshake_request = HANDSHAKE_RESPONDER_READER.read(decoder)
    handshake_response = {}

    # determine the remote protocol
    client_hash = handshake_request.get('clientHash')
    client_protocol = handshake_request.get('clientProtocol')
    remote_protocol = self.get_protocol_cache(client_hash)
    if remote_protocol is None and client_protocol is not None:
      remote_protocol = protocol.parse(client_protocol)
      self.set_protocol_cache(client_hash, remote_protocol)

    # evaluate remote's guess of the local protocol
    server_hash = handshake_request.get('serverHash')
    if self.local_hash == server_hash:
      if remote_protocol is None:
        handshake_response['match'] = 'NONE'
      else:
        handshake_response['match'] = 'BOTH'
    else:
      if remote_protocol is None:
        handshake_response['match'] = 'NONE'
      else:
        handshake_response['match'] = 'CLIENT'

    if handshake_response['match'] != 'BOTH':
      handshake_response['serverProtocol'] = str(self.local_protocol)
      handshake_response['serverHash'] = self.local_hash

    HANDSHAKE_RESPONDER_WRITER.write(handshake_response, encoder)
    return remote_protocol
示例#12
0
    def process_handshake(self, decoder, encoder):
        handshake_request = HANDSHAKE_RESPONDER_READER.read(decoder)
        handshake_response = {}

        # determine the remote protocol
        client_hash = handshake_request.get('clientHash')
        client_protocol = handshake_request.get('clientProtocol')
        remote_protocol = self.get_protocol_cache(client_hash)
        if remote_protocol is None and client_protocol is not None:
            remote_protocol = protocol.parse(client_protocol)
            self.set_protocol_cache(client_hash, remote_protocol)

        # evaluate remote's guess of the local protocol
        server_hash = handshake_request.get('serverHash')
        if self.local_hash == server_hash:
            if remote_protocol is None:
                handshake_response['match'] = 'NONE'
            else:
                handshake_response['match'] = 'BOTH'
        else:
            if remote_protocol is None:
                handshake_response['match'] = 'NONE'
            else:
                handshake_response['match'] = 'CLIENT'

        if handshake_response['match'] != 'BOTH':
            handshake_response['serverProtocol'] = str(self.local_protocol)
            handshake_response['serverHash'] = self.local_hash

        HANDSHAKE_RESPONDER_WRITER.write(handshake_response, encoder)
        return remote_protocol
def process(a_file, output_dir='out'):
	avpr_str = open(a_file, 'rb').read()
	name_topic_map = get_name_to_topic_map(avpr_str)
	x_proto = protocol.parse(avpr_str)
	for the_type in x_proto.types:
		if the_type.name in name_topic_map:
			topic = name_topic_map[the_type.name]
			try:
				if 0 == len(getattr(the_type, 'fields', [])):
					print "%s has no subschema to iterate over" % topic
					continue
				msg = generate_json_test_message(the_type)
				if msg:
					print "Generated a test message for %s." % topic
					target = join(output_dir, topic.strip('/'))
					try:
						makedirs(target)
					except OSError:
						pass
					filename = join(target, 'index.json')
					open(filename, 'w').write(dumps(msg))
				else:
					import pdb; pdb.set_trace()

			except RecursiveSchemaError, e:
				print "Could not generate a test message for %s. (%s)" % (topic, e.message)
示例#14
0
    def testParse(self):
        correct = 0
        for iexample, example in enumerate(EXAMPLES):
            logging.debug('Parsing protocol #%d:\n%s', iexample,
                          example.protocol_string)
            try:
                parsed = protocol.parse(example.protocol_string)
                if example.valid:
                    correct += 1
                else:
                    self.fail('Invalid protocol was parsed:\n%s' %
                              example.protocol_string)
            except Exception as exn:
                if example.valid:
                    self.fail(
                        'Valid protocol failed to parse: %s\n%s' %
                        (example.protocol_string, traceback.format_exc()))
                else:
                    if logging.getLogger().getEffectiveLevel() <= 5:
                        logging.debug('Expected error:\n%s',
                                      traceback.format_exc())
                    else:
                        logging.debug('Expected error: %r', exn)
                    correct += 1

        self.assertEqual(
            correct, len(EXAMPLES),
            'Parse behavior correct on %d out of %d protocols.' %
            (correct, len(EXAMPLES)))
示例#15
0
def main(avprFile, outputFolder):
    if not os.path.exists(outputFolder):
        os.makedirs(outputFolder)
    schema_formats = avpr.parse(open(avprFile, "r").read())
    sorted([(v.type, k) for k, v in schema_formats.types_dict.items()])
    for k, v in schema_formats.types_dict.items():
        logging.info('Processing key:' + str(k))
        checkAndProcessSchema(k, v.to_json(), outputFolder)
示例#16
0
def main(avprFile,outputFolder):
	if not os.path.exists(outputFolder):
		os.makedirs(outputFolder)
	schema_formats = avpr.parse(open(avprFile, "r").read()) 
	sorted([(v.type, k) for k, v in schema_formats.types_dict.items()])
	for k, v in schema_formats.types_dict.items():
		logging.info('Processing key:'+str(k))
		checkAndProcessSchema(k,v.to_json(),outputFolder)
示例#17
0
    def process_handshake(self, decoder, encoder):
        handshake_response = {}
        try:
            handshake_request = DatumReader(
                _load_request_schema()).read(decoder)
        except SchemaResolutionException:
            if self.local_protocol is None:
                handshake_response['match'] = 'NONE'
                handshake_response['serverProtocol'] = str(NO_FOUND)
                handshake_response['serverHash'] = NO_FOUND.md5
                DatumWriter(_load_response_schema()).write(
                    handshake_response, encoder)
                raise HandshakeError(encoder.writer.getvalue())
            # reset reader
            decoder.reader.seek(0, 0)
            return self.local_protocol

        client_hash = handshake_request.get('clientHash')
        client_protocol = handshake_request.get('clientProtocol')
        remote_protocol = self.get_protocol_cache(client_hash)

        # new handshake
        if remote_protocol is None and client_protocol is None:
            handshake_response['match'] = 'NONE'
            handshake_response['serverProtocol'] = str(NO_FOUND)
            handshake_response['serverHash'] = NO_FOUND.md5
            DatumWriter(_load_response_schema()).write(handshake_response,
                                                       encoder)
            return remote_protocol

        # client request handshake
        if remote_protocol is None and client_protocol is not None:
            # compare with client_protocol and cache_protocol
            self._local_protocol = self.contains(client_protocol)
            if self.local_protocol is None:
                handshake_response['match'] = 'NONE'
                handshake_response['serverProtocol'] = str(NO_FOUND)
                handshake_response['serverHash'] = NO_FOUND.md5
                DatumWriter(_load_response_schema()).write(
                    handshake_response, encoder)
                raise HandshakeError(encoder.writer.getvalue())
            else:
                remote_protocol = protocol.parse(client_protocol)
                self.set_protocol_cache(client_hash, remote_protocol)
                handshake_response['match'] = 'CLIENT'
                handshake_response['serverProtocol'] = str(self.local_protocol)
                handshake_response['serverHash'] = self.local_protocol.md5
                DatumWriter(_load_response_schema()).write(
                    handshake_response, encoder)
                return remote_protocol

        # success handshake
        if remote_protocol is not None:
            handshake_response['match'] = 'BOTH'

        DatumWriter(_load_response_schema()).write(handshake_response, encoder)
        return remote_protocol
示例#18
0
文件: test_protocol.py 项目: 10sr/hue
 def test_inner_namespace_set(self):
   print ''
   print 'TEST INNER NAMESPACE'
   print '==================='
   print ''
   proto = protocol.parse(HELLO_WORLD.protocol_string)
   self.assertEqual(proto.namespace, "com.acme")
   greeting_type = proto.types_dict['Greeting']
   self.assertEqual(greeting_type.namespace, 'com.acme')
示例#19
0
  def test_parse(self):
    num_correct = 0
    for example in EXAMPLES:
      try:
        protocol.parse(example.protocol_string)
        if example.valid:
          num_correct += 1
        else:
          self.fail("Parsed invalid protocol: %s" % (example.name,))
      except Exception as e:
        if not example.valid:
          num_correct += 1
        else:
          self.fail("Coudl not parse valid protocol: %s" % (example.name,))

    fail_msg = "Parse behavior correct on %d out of %d protocols." % \
      (num_correct, len(EXAMPLES))
    self.assertEqual(num_correct, len(EXAMPLES), fail_msg)
示例#20
0
 def test_inner_namespace_set(self):
   print('')
   print('TEST INNER NAMESPACE')
   print('===================')
   print('')
   proto = protocol.parse(HELLO_WORLD.protocol_string)
   self.assertEqual(proto.namespace, "com.acme")
   greeting_type = proto.types_dict['Greeting']
   self.assertEqual(greeting_type.namespace, 'com.acme')
示例#21
0
    def testValidCastToStringAfterParse(self):
        """
        Test that the string generated by an Avro Protocol object is,
        in fact, a valid Avro protocol.
        """
        num_correct = 0
        for example in VALID_EXAMPLES:
            proto = protocol.parse(example.protocol_string)
            try:
                protocol.parse(str(proto))
                logging.debug('Successfully reparsed protocol:\n%s', example.protocol_string)
                num_correct += 1
            except:
                logging.debug('Failed to reparse protocol:\n%s', example.protocol_string)

        fail_msg = (
            'Cast to string success on %d out of %d protocols'
            % (num_correct, len(VALID_EXAMPLES)))
        self.assertEqual(num_correct, len(VALID_EXAMPLES), fail_msg)
示例#22
0
    def testValidCastToStringAfterParse(self):
        """
        Test that the string generated by an Avro Protocol object is,
        in fact, a valid Avro protocol.
        """
        num_correct = 0
        for example in VALID_EXAMPLES:
            proto = protocol.parse(example.protocol_string)
            try:
                protocol.parse(str(proto))
                logging.debug('Successfully reparsed protocol:\n%s',
                              example.protocol_string)
                num_correct += 1
            except:
                logging.debug('Failed to reparse protocol:\n%s',
                              example.protocol_string)

        fail_msg = ('Cast to string success on %d out of %d protocols' %
                    (num_correct, len(VALID_EXAMPLES)))
        self.assertEqual(num_correct, len(VALID_EXAMPLES), fail_msg)
示例#23
0
  def test_parse(self):
    print ''
    print 'TEST PARSE'
    print '=========='
    print ''

    num_correct = 0
    for example in EXAMPLES:
      try:
        protocol.parse(example.protocol_string)
        if example.valid: num_correct += 1
        debug_msg = "%s: PARSE SUCCESS" % example.name
      except:
        if not example.valid: num_correct += 1
        debug_msg = "%s: PARSE FAILURE" % example.name
      finally:
        print debug_msg

    fail_msg = "Parse behavior correct on %d out of %d protocols." % \
      (num_correct, len(EXAMPLES))
    self.assertEqual(num_correct, len(EXAMPLES), fail_msg)
示例#24
0
	def __init__(self, sc):
		# Set the PySpark context
		self._sc = sc
		
		# Load the ADAM avro record schema
		self._adam_record_schema = apr.parse(open("adam.avpr", "r").read()) 
		
		# Set the JavaSparkContext
		self._jsc = sc._jsc
		
		# Store the parquet context which as a loader
		self._pc = self._sc._jvm.PythonADAMContext(self._sc._jsc.sc())
示例#25
0
    def get_protocol(self, name, version=None):
        """
        Retrieves an avro.protocol object.

        First loads the protocol string, then parses it by calling the
        avro.protocol parser.

        :param name: a service name.
        :param version: an optional version.
        :return: an avro.protocol.Protocol object.
        """
        contents = self.get_protocol_string(name, version=version)
        return avro_protocol.parse(contents)
示例#26
0
    def testEquivalenceAfterRoundTrip(self):
        """
        1. Given a string, parse it to get Avro protocol "original".
        2. Serialize "original" to a string and parse that string
         to generate Avro protocol "round trip".
        3. Ensure "original" and "round trip" protocols are equivalent.
        """
        num_correct = 0
        for example in VALID_EXAMPLES:
            original_protocol = protocol.parse(example.protocol_string)
            round_trip_protocol = protocol.parse(str(original_protocol))

            if original_protocol == round_trip_protocol:
                num_correct += 1
                logging.debug('Successful round-trip for protocol:\n%s', example.protocol_string)
            else:
                self.fail('Round-trip failure for protocol:\n%s\nOriginal protocol:\n%s'
                          % (example.protocol_string, str(original_protocol)))

        self.assertEqual(
            num_correct,
            len(VALID_EXAMPLES),
            'Round trip success on %d out of %d protocols.' % (num_correct, len(VALID_EXAMPLES)))
示例#27
0
 def read_handshake_response(self, decoder):
     handshake_response = HANDSHAKE_REQUESTOR_READER.read(decoder)
     match = handshake_response.get('match')
     if match == 'BOTH':
         self.send_protocol = False
         return True
     elif match == 'CLIENT':
         if self.send_protocol:
             raise schema.AvroException('Handshake failure.')
         self.remote_protocol = protocol.parse(
             handshake_response.get('serverProtocol'))
         self.remote_hash = handshake_response.get('serverHash')
         self.send_protocol = False
         return True
     elif match == 'NONE':
         if self.send_protocol:
             raise schema.AvroException('Handshake failure.')
         self.remote_protocol = protocol.parse(
             handshake_response.get('serverProtocol'))
         self.remote_hash = handshake_response.get('serverHash')
         self.send_protocol = True
         return False
     else:
         raise schema.AvroException('Unexpected match: %s' % match)
示例#28
0
文件: ipc.py 项目: AlexChen12/avro
 def read_handshake_response(self, decoder):
   handshake_response = HANDSHAKE_REQUESTOR_READER.read(decoder)
   match = handshake_response.get('match')
   if match == 'BOTH':
     self.send_protocol = False
     return True
   elif match == 'CLIENT':
     if self.send_protocol:
       raise schema.AvroException('Handshake failure.')
     self.remote_protocol = protocol.parse(
                            handshake_response.get('serverProtocol'))
     self.remote_hash = handshake_response.get('serverHash')
     self.send_protocol = False
     return True
   elif match == 'NONE':
     if self.send_protocol:
       raise schema.AvroException('Handshake failure.')
     self.remote_protocol = protocol.parse(
                            handshake_response.get('serverProtocol'))
     self.remote_hash = handshake_response.get('serverHash')
     self.send_protocol = True
     return False
   else:
     raise schema.AvroException('Unexpected match: %s' % match)
示例#29
0
    def from_filename(endpoint_name, protocol_file_path):
        """
        Creates a AvroAPIEndpoint from protocol file identified by the protocol_file_path.

        :param endpoint_name: The name of the endpoint.
        :param protocol_file_path: The path to the specific protocol file to parse.
        :return: The AvroAPIEndpoint
        :rtype: user_service.helpers.avro.AvroAPIEndpoint
        """

        with open(protocol_file_path) as _file:
            protocol = a_protocol.parse(_file.read())

        endpoint = FlaskAvroEndpoint(endpoint_name, protocol)

        return endpoint
示例#30
0
    def from_filename(endpoint_name, protocol_file_path):
        """
        Creates a AvroAPIEndpoint from protocol file identified by the protocol_file_path.

        :param endpoint_name: The name of the endpoint.
        :param protocol_file_path: The path to the specific protocol file to parse.
        :return: The AvroAPIEndpoint
        :rtype: user_service.helpers.avro.AvroAPIEndpoint
        """

        with open(protocol_file_path) as _file:
            protocol = a_protocol.parse(_file.read())

        endpoint = FlaskAvroEndpoint(endpoint_name, protocol)

        return endpoint
示例#31
0
    def _process_handshake(self, decoder, encoder):
        """Processes an RPC handshake.

        Args:
            decoder: Where to read from.
            encoder: Where to write to.
        Returns:
            The requested Protocol.
        """
        handshake_request = HANDSHAKE_RESPONDER_READER.read(decoder)
        logging.debug("Processing handshake request: %s", handshake_request)

        # determine the remote protocol
        client_hash = handshake_request.get("clientHash")
        client_protocol = handshake_request.get("clientProtocol")
        remote_protocol = self.get_protocol_cache(client_hash)
        if remote_protocol is None and client_protocol is not None:
            remote_protocol = protocol.parse(client_protocol)
            self.set_protocol_cache(client_hash, remote_protocol)

        # evaluate remote's guess of the local protocol
        server_hash = handshake_request.get("serverHash")

        if remote_protocol is None:
            match = "NONE"
        elif self._local_hash == server_hash:
            match = "BOTH"
        else:
            match = "CLIENT"

        # HandshakeResponse:
        handshake_response = {
            "match": match,
            "serverProtocol": None,
            "serverHash": None,
            "meta": None,
        }

        if match != "BOTH":
            handshake_response["serverProtocol"] = str(self.local_protocol)
            handshake_response["serverHash"] = self._local_hash

        logging.debug("Handshake response: %s", handshake_response)
        HANDSHAKE_RESPONDER_WRITER.write(handshake_response, encoder)
        return remote_protocol
示例#32
0
文件: ipc.py 项目: davnoe/kiji
    def _process_handshake(self, decoder, encoder):
        """Processes an RPC handshake.

        Args:
            decoder: Where to read from.
            encoder: Where to write to.
        Returns:
            The requested Protocol.
        """
        handshake_request = HANDSHAKE_RESPONDER_READER.read(decoder)
        logging.debug("Processing handshake request: %s", handshake_request)

        # determine the remote protocol
        client_hash = handshake_request.get("clientHash")
        client_protocol = handshake_request.get("clientProtocol")
        remote_protocol = self.get_protocol_cache(client_hash)
        if remote_protocol is None and client_protocol is not None:
            remote_protocol = protocol.parse(client_protocol)
            self.set_protocol_cache(client_hash, remote_protocol)

        # evaluate remote's guess of the local protocol
        server_hash = handshake_request.get("serverHash")

        if remote_protocol is None:
            match = "NONE"
        elif self._local_hash == server_hash:
            match = "BOTH"
        else:
            match = "CLIENT"

        # HandshakeResponse:
        handshake_response = {
            "match": match,
            "serverProtocol": None,
            "serverHash": None,
            "meta": None,
        }

        if match != "BOTH":
            handshake_response["serverProtocol"] = str(self.local_protocol)
            handshake_response["serverHash"] = self._local_hash

        logging.debug("Handshake response: %s", handshake_response)
        HANDSHAKE_RESPONDER_WRITER.write(handshake_response, encoder)
        return remote_protocol
示例#33
0
  def _ProcessHandshake(self, decoder, encoder):
    """Processes an RPC handshake.

    Args:
      decoder: Where to read from.
      encoder: Where to write to.
    Returns:
      The requested Protocol.
    """
    handshake_request = HANDSHAKE_RESPONDER_READER.read(decoder)
    logger.info('Processing handshake request: %s', handshake_request)

    # determine the remote protocol
    client_hash = handshake_request.get('clientHash')
    client_protocol = handshake_request.get('clientProtocol')
    remote_protocol = self.get_protocol_cache(client_hash)
    if remote_protocol is None and client_protocol is not None:
      remote_protocol = protocol.parse(client_protocol)
      self.set_protocol_cache(client_hash, remote_protocol)

    # evaluate remote's guess of the local protocol
    server_hash = handshake_request.get('serverHash')

    handshake_response = {}
    if self._local_hash == server_hash:
      if remote_protocol is None:
        handshake_response['match'] = 'NONE'
      else:
        handshake_response['match'] = 'BOTH'
    else:
      if remote_protocol is None:
        handshake_response['match'] = 'NONE'
      else:
        handshake_response['match'] = 'CLIENT'

    if handshake_response['match'] != 'BOTH':
      handshake_response['serverProtocol'] = str(self.local_protocol)
      handshake_response['serverHash'] = self._local_hash

    logger.info('Handshake response: %s', handshake_response)
    HANDSHAKE_RESPONDER_WRITER.write(handshake_response, encoder)
    return remote_protocol
    def test_client_attributes(self):
        with open(protocol_file) as _file:
            protocol_string = _file.read()

        protocol = avro_protocol.parse(protocol_string)
        avro_client = avro_ipc.Requestor(protocol, None)
        client = core.Client(avro_client)

        self.assertTrue(hasattr(client, "foo"))
        self.assertIsInstance(client.foo, types.MethodType)

        with mock.patch.object(client._client, "request", return_value="bar"):
            self.assertRaises(
                TypeError,
                client.foo,
                baz="fizz"
            )

            response = client.foo()
            self.assertEqual("bar", response)

            response = client.foo(bar="baz")
            self.assertEqual("bar", response)
示例#35
0
文件: ipc.py 项目: vjykumar/avro
    def __handshake(self, transceiver, decoder, encoder):
        request = _HANDSHAKE_RESPONDER_READER.read(decoder)
        remoteproto = self.__protocols.get(request.clientHash)
        if remoteproto is None and request.clientProtocol is not None:
            remoteproto = protocol.parse(request.clientProtocol)
            self.__protocols[request.clientHash] = remoteproto
        response = _HandshakeResponse()

        if self.__localhash == request.serverHash:
            if remoteproto is None:
                response.match = _HANDSHAKE_MATCH_NONE
            else:
                response.match = _HANDSHAKE_MATCH_BOTH
        else:
            if remoteproto is None:
                response.match = _HANDSHAKE_MATCH_NONE
            else:
                response.match = _HANDSHAKE_MATCH_CLIENT
        if response.match != _HANDSHAKE_MATCH_BOTH:
            response.serverProtocol = unicode(self.__localproto.__str__(),
                                              "utf8")
            response.serverHash = self.__localhash
        _HANDSHAKE_RESPONDER_WRITER.write(response, encoder)
        return remoteproto
示例#36
0
文件: tool.py 项目: 10sr/hue
def send_message(uri, proto, msg, datum):
  url_obj = urlparse.urlparse(uri)
  client = ipc.HTTPTransceiver(url_obj.hostname, url_obj.port)
  proto_json = file(proto, 'r').read()
  requestor = ipc.Requestor(protocol.parse(proto_json), client)
  print requestor.request(msg, datum)
示例#37
0
import os
import sys

import avro.ipc as ipc
import avro.protocol as protocol

# TODO(hammer): Figure the canonical place to put this file
PROTO_FILE = os.path.join(os.path.dirname(__file__), 'schema/hbase.avpr')
PROTOCOL = protocol.parse(open(PROTO_FILE).read())

def retry_wrapper(fn):
  """a decorator to add retry symantics to any method that uses hbase"""
  def f(self, *args, **kwargs):
    try:
      return fn(self, *args, **kwargs)
    except:
      try:
        self.close()
      except:
        pass
      self.make_connection()
      return fn(self, *args, **kwargs)
  return f

class HBaseConnection(object):
  """
  Base class for HBase connections.  Supplies methods for a few basic
  queries and methods for cleanup of thrift results.
  """
  def __init__(self, host, port):
    self.host = host
示例#38
0
inputProtocol = None
outputProtocol = None

TaskType = None
if (inputProtocol is None):
    pfile = os.path.split(__file__)[0] + os.sep + "InputProtocol.avpr"

    if not (os.path.exists(pfile)):
        raise Exception(
            "Could not locate the InputProtocol: {0} does not exist".format(
                pfile))

    with file(pfile, 'r') as hf:
        prototxt = hf.read()

    inputProtocol = protocol.parse(prototxt)

    # use a named tuple to represent the tasktype enumeration
    taskschema = inputProtocol.types_dict["TaskType"]
    _ttype = collections.namedtuple("_tasktype", taskschema.symbols)
    TaskType = _ttype(*taskschema.symbols)

if (outputProtocol is None):
    pfile = os.path.split(__file__)[0] + os.sep + "OutputProtocol.avpr"

    if not (os.path.exists(pfile)):
        raise Exception(
            "Could not locate the OutputProtocol: {0} does not exist".format(
                pfile))

    with file(pfile, 'r') as hf:
示例#39
0
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import httplib

import avro.ipc as ipc
import avro.protocol as protocol

PROTOCOL = protocol.parse(open("../../serdes/avro/mail.avpr").read())

server_addr = ('127.0.0.1', 9090)

class UsageError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

if __name__ == '__main__':
    if len(sys.argv) != 4:
        raise UsageError("Usage: <to> <from> <body>")

    # client code - attach to the server and send a message
    client = ipc.HTTPTransceiver(server_addr[0], server_addr[1])
示例#40
0
"""
import time
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
from SocketServer import ThreadingMixIn
from multiprocessing import Queue
from threading import Thread

import avro.ipc as ipc
import avro.protocol as protocol
import avro.schema as schema
import numpy as np
import yaml
from termcolor import colored

# data packet format definition
PROTOCOL = protocol.parse(open('resource/image.avpr').read())


class Initializer:
    """
        Singleton factory for initializer. The Initializer module has two timers.
        The node_timer is for recording statistics for block1 layer model inference
        time. The timer is for recording the total inference time from last
        fully connected layer.

        Attributes:
            queue: Queue for storing available block1 models devices.
            start: Start time of getting a frame.
            count: Total Number of frames gets back.
            node_total: Total layer-wise time.
            node_count: Total layer-wise frame count.
示例#41
0
def send_message(uri, proto, msg, datum):
    url_obj = urlparse.urlparse(uri)
    client = ipc.HTTPTransceiver(url_obj.hostname, url_obj.port)
    proto_json = file(proto, 'r').read()
    requestor = ipc.Requestor(protocol.parse(proto_json), client)
    print requestor.request(msg, datum)
示例#42
0
# -*- coding: utf-8 -*- 
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import threading
import avro.ipc as ipc
import avro.protocol as protocol
import avro.schema as schema
import thread

PROTOCOL = protocol.parse(open("../../avro/pingpong.avpr").read())
server_addr = ('localhost', 9090)


class PingpongResponder(ipc.Responder):
    def __init__(self):
        ipc.Responder.__init__(self, PROTOCOL)

    def invoke(self, msg, req):
        if msg.name == 'send':
            return "pong"
        else:
            raise schema.AvroException("unexpected message:", msg.getname())


class PingpongHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        self.responder = PingpongResponder()
        call_request_reader = ipc.FramedReader(self.rfile)
        call_request = call_request_reader.read_framed_message()

        resp_body = self.responder.respond(call_request)
示例#43
0
 def test_inner_namespace_not_rendered(self):
   proto = protocol.parse(HELLO_WORLD.protocol_string)
   self.assertEqual('com.acme.Greeting', proto.types[0].fullname)
   self.assertEqual('Greeting', proto.types[0].name)
   # but there shouldn't be 'namespace' rendered to json on the inner type
   self.assertFalse('namespace' in proto.to_json()['types'][0])
示例#44
0
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import avro.ipc as ipc
import avro.protocol as protocol
import avro.schema as schema
from movie_service_util import MovieServiceUtil

# PROTOCOL = protocol.parse(open("../avro/mail.avpr").read())
PROTOCOL = protocol.parse(open("../avro/movieservice.avpr").read())


class MovieServiceResponder(ipc.Responder):
    def __init__(self):
        ipc.Responder.__init__(self, PROTOCOL)
        self.moviesData = MovieServiceUtil.create_movies()

    def invoke(self, msg, req):
        # print("message: " + str(msg))
        # print("req:" + str(req))
        # print("messsage name :" + str(msg.name))
        if msg.name == 'getMovies':
            # print("request to be processed")
            # print("local data: " + str(self.moviesData))
            return self.moviesData
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

import avro.ipc as ipc
import avro.protocol as protocol
import avro.schema as schema

PROTOCOL = protocol.parse(open("../mail.avpr").read())
HOST = ('localhost', 5000)

class MailResponder(ipc.Responder):
    def __init__(self):
        ipc.Responder.__init__(self, PROTOCOL)

    def invoke(self, msg, req):
        if msg.name == 'send':
            message = req['message']
            return ("Sent message to " + message['to']
                    + " from " + message['from']
                    + " with body " + message['body'])
        else:
            raise schema.AvroException("unexpected message:", msg.getname())

class MailHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        self.responder = MailResponder()
        call_request_reader = ipc.FramedReader(self.rfile)
        call_request = call_request_reader.read_framed_message()
        resp_body = self.responder.respond(call_request)
        self.send_response(200)
        self.send_header('Content-Type', 'avro/binary')
        self.end_headers()
示例#46
0
     }
 ],

 "messages": {
     "send": {
         "request": [{"name": "message", "type": "Message"}],
         "response": "string"
     },
     "replay": {
         "request": [],
         "response": "string"
     }
 }
}
"""
MAIL_PROTOCOL = protocol.parse(MAIL_PROTOCOL_JSON)
SERVER_HOST = 'localhost'
SERVER_PORT = 9090

class UsageError(Exception):
  def __init__(self, value):
    self.value = value
  def __str__(self):
    return repr(self.value)

def make_requestor(server_host, server_port, protocol):
  client = ipc.HTTPTransceiver(SERVER_HOST, SERVER_PORT)
  return ipc.Requestor(protocol, client)

if __name__ == '__main__':
  if len(sys.argv) not in [4, 5]:
示例#47
0
文件: testipc.py 项目: jivega/avro
#http://www.apache.org/licenses/LICENSE-2.0
#
#Unless required by applicable law or agreed to in writing, software
#distributed under the License is distributed on an "AS IS" BASIS,
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#See the License for the specific language governing permissions and
#limitations under the License.

import unittest, socket, struct
import testio
import avro.ipc as ipc
import avro.genericipc as genericipc
import avro.protocol as protocol
import avro.schema as schema

PROTOCOL = protocol.parse(open("src/test/schemata/simple.avpr").read())

class TestProtocol(unittest.TestCase):

  class TestResponder(genericipc.Responder):

    def __init__(self):
      ipc.ResponderBase.__init__(self, PROTOCOL)

    def invoke(self, msg, req):
      if msg.getname() == 'hello':
        print "hello:", req.get("greeting")
        return unicode('goodbye')
      elif msg.getname() == 'echo':
        rec = req.get("record")
        print "echo:", rec
示例#48
0
 def load_protocol():
     avpr = os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir), "avro/services.avpr")
     return protocol.parse(open(avpr).read())
示例#49
0
文件: tool.py 项目: 10sr/hue
 def __init__(self, proto, msg, datum):
   proto_json = file(proto, 'r').read()
   ipc.Responder.__init__(self, protocol.parse(proto_json))
   self.msg = msg
   self.datum = datum
示例#50
0
 def __init__(self, proto, msg, datum):
     proto_json = file(proto, 'r').read()
     ipc.Responder.__init__(self, protocol.parse(proto_json))
     self.msg = msg
     self.datum = datum
示例#51
0
import avro.ipc as ipc
import avro.protocol as protocol

avroProtocol = protocol.parse(open("tweetWithAvr.avr").read())

java_rpc_server_address = ("localhost", 9090)

if __name__ == "__main__":

    client = ipc.HTTPTransceiver(java_rpc_server_address[0], java_rpc_server_address[1])
    requestor = ipc.Requestor(avroProtocol, client)

    tweet = {"tweetId": 1, "username": "******", "text": "This is a tweet from python"}

    params = {"tweet": tweet}
    requestor.request("sendTweet", params)
    client.close()
示例#52
0
     }
 ],

 "messages": {
     "send": {
         "request": [{"name": "message", "type": "Message"}],
         "response": "string"
     },
     "replay": {
         "request": [],
         "response": "string"
     }
 }
}
"""
MAIL_PROTOCOL = protocol.parse(MAIL_PROTOCOL_JSON)
SERVER_HOST = 'localhost'
SERVER_PORT = 9090


def make_requestor(server_host, server_port, protocol):
    client = ipc.HTTPTransceiver(SERVER_HOST, SERVER_PORT)
    return ipc.Requestor(protocol, client)


if __name__ == '__main__':
    if len(sys.argv) not in [4, 5]:
        raise avro.errors.UsageError("Usage: <to> <from> <body> [<count>]")

    # client code - attach to the server and send a message
    # fill in the Message record
def get_client(host='127.0.0.1', port=9170):
    schema = os.path.join(root, 'interface/avro', 'cassandra.avpr')
    proto = protocol.parse(open(schema).read())
    client = ipc.HTTPTransceiver(host, port)
    return ipc.Requestor(proto, client)
示例#54
0
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import httplib

import avro.ipc as ipc
import avro.protocol as protocol

PROTOCOL = protocol.parse(open("../../avro/example/mail.avpr").read())

server_addr = ('127.0.0.1', 9090)

class UsageError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

if __name__ == '__main__':
    if len(sys.argv) != 4:
        raise UsageError("Usage: <to> <from> <body>")

    # client code - attach to the server and send a message
    client = ipc.HTTPTransceiver(server_addr[0], server_addr[1])
示例#55
0
import requests
import time

import MySQLdb

import avro.ipc as ipc
import avro.protocol as protocol
from utils.accesskeys import getAccessPropertiesFromConfigService, get_key_from_configservice
from utils.locallogging import debug

splice_path = os.path.join(os.path.dirname(__file__), 'protocols/Splice.avpr')

if not os.path.isfile(splice_path):
    exit(1)

PROTOCOL = protocol.parse(open(splice_path).read())

if __name__ == '__main__':
    db_host = get_key_from_configservice(key="/helix-aws/spliceui_dbhost")
    db_user = get_key_from_configservice(key="/helix-aws/spliceui_dbuser")
    db_pass = get_key_from_configservice(key="/helix-aws/spliceui_dbpass")

    db = MySQLdb.connect(host=db_host, user=db_user, passwd=db_pass)

    users_and_lists = {}

    now = time.strftime("%Y-%m-%d %H:%M:%S")

    cur = db.cursor()
    cur.execute(
        "SELECT id, name, primaryEmail AS email, createdate AS create_date, termsacceptancedate AS terms_date, emailverified AS verified FROM InomeSpliceUI.Customers WHERE createdate > DATE_SUB('%s', INTERVAL 24 HOUR) AND createdate <= '%s' ORDER BY createdate DESC"
示例#56
0
from threading import Thread
import tensorflow as tf
from keras.layers import Dense, Input
from keras.models import Model
import avro.ipc as ipc
import avro.protocol as protocol
import numpy as np
import time

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

PATH = os.path.abspath(__file__)
DIR_PATH = os.path.dirname(PATH)

# read data packet format.
PROTOCOL = protocol.parse(
    open(DIR_PATH + '/resource/message/message.avpr').read())
SIZE = 10


class Responder(ipc.Responder):
    """ Responder called by handler when got request. """
    def __init__(self):
        ipc.Responder.__init__(self, PROTOCOL)

    def invoke(self, msg, req):
        """
            This function is invoked by do_POST to handle the request. Invoke handles
            the request and get response for the request. This is the key of each node.
            All models forwarding and output redirect are done here. Because the invoke
            method of initializer only needs to receive the data packet, it does not do
            anything in the function and return None.
示例#57
0
def generate_protocol(protocol_json, use_logical_types=False, custom_imports=None, avro_json_converter=None):
    """
    Generate content of the file which will contain concrete classes for RecordSchemas and requests contained
    in the avro protocol
    :param str protocol_json: JSON containing avro protocol
    :param bool use_logical_types: Use logical types extensions if true
    :param list[str] custom_imports: Add additional import modules
    :param str avro_json_converter: AvroJsonConverter type to use for default values
    :return:
    """

    if avro_json_converter is None:
        avro_json_converter = 'avrojson.AvroJsonConverter'

    if '(' not in avro_json_converter:
        avro_json_converter += '(use_logical_types=%s, schema_types=__SCHEMA_TYPES)' % use_logical_types

    custom_imports = custom_imports or []

    if six.PY3:
        proto = protocol.Parse(protocol_json)
    else:
        proto = protocol.parse(protocol_json)

    schemas = []
    messages = []
    schema_names = set()
    request_names = set()

    known_types = set()
    for schema_idx, record_schema in enumerate(proto.types):
        if isinstance(record_schema, (schema.RecordSchema, schema.EnumSchema)):
            schemas.append((schema_idx, record_schema))
            known_types.add(clean_fullname(record_schema.fullname))

    for message in (six.itervalues(proto.messages) if six.PY2 else proto.messages):
        messages.append((message, message.request, message.response if isinstance(message.response, (
            schema.EnumSchema, schema.RecordSchema)) and clean_fullname(message.response.fullname) not in known_types else None))
        if isinstance(message.response, (schema.EnumSchema, schema.RecordSchema)):
            known_types.add(clean_fullname(message.response.fullname))

    namespaces = {}
    for schema_idx, record_schema in schemas:
        ns, name = ns_.split_fullname(clean_fullname(record_schema.fullname))
        if ns not in namespaces:
            namespaces[ns] = {'requests': [], 'records': [], 'responses': []}
        namespaces[ns]['records'].append((schema_idx, record_schema))

    for message, request, response in messages:
        fullname = ns_.make_fullname(proto.namespace, clean_fullname(message.name))
        ns, name = ns_.split_fullname(fullname)
        if ns not in namespaces:
            namespaces[ns] = {'requests': [], 'records': [], 'responses': []}
        namespaces[ns]['requests'].append(message)
        if response:
            namespaces[ns]['responses'].append(message)

    main_out = StringIO()
    writer = TabbedWriter(main_out)

    write_preamble(writer, use_logical_types, custom_imports)
    write_protocol_preamble(writer, use_logical_types, custom_imports)
    write_get_schema(writer)
    write_populate_schemas(writer)

    writer.write('\n\n\nclass SchemaClasses(object):')
    with writer.indent():
        writer.write('\n\n')

        current_namespace = tuple()
        all_ns = sorted(namespaces.keys())

        for ns in all_ns:
            if not (namespaces[ns]['responses'] or namespaces[ns]['records']):
                continue

            namespace = ns.split('.')
            if namespace != current_namespace:
                start_namespace(current_namespace, namespace, writer)

            for idx, record in namespaces[ns]['records']:
                schema_names.add(clean_fullname(record.fullname))
                if isinstance(record, schema.RecordSchema):
                    write_schema_record(record, writer, use_logical_types)
                elif isinstance(record, schema.EnumSchema):
                    write_enum(record, writer)

            for message in namespaces[ns]['responses']:
                schema_names.add(clean_fullname(message.response.fullname))
                if isinstance(message.response, schema.RecordSchema):
                    write_schema_record(message.response, writer, use_logical_types)
                elif isinstance(message.response, schema.EnumSchema):
                    write_enum(message.response, writer)

        writer.write('\n\npass')

    writer.set_tab(0)
    writer.write('\n\n\nclass RequestClasses(object):')
    with writer.indent() as indent:
        writer.write('\n\n')

        current_namespace = tuple()
        all_ns = sorted(namespaces.keys())

        for ns in all_ns:
            if not (namespaces[ns]['requests'] or namespaces[ns]['responses']):
                continue

            namespace = ns.split('.')
            if namespace != current_namespace:
                start_namespace(current_namespace, namespace, writer)

            for message in namespaces[ns]['requests']:
                request_names.add(ns_.make_fullname(proto.namespace, clean_fullname(message.name)))
                write_protocol_request(message, proto.namespace, writer, use_logical_types)

        writer.write('\n\npass')

    writer.untab()
    writer.set_tab(0)
    writer.write('\n__SCHEMA_TYPES = {\n')
    writer.tab()

    all_ns = sorted(namespaces.keys())
    for ns in all_ns:
        for idx, record in (namespaces[ns]['records'] or []):
            writer.write("'%s': SchemaClasses.%sClass,\n" % (clean_fullname(record.fullname),
                                                             clean_fullname(record.fullname)))

        for message in (namespaces[ns]['responses'] or []):
            writer.write("'%s': SchemaClasses.%sClass,\n" % (clean_fullname(message.response.fullname),
                                                             clean_fullname(message.response.fullname)))

        for message in (namespaces[ns]['requests'] or []):
            name = ns_.make_fullname(proto.namespace, clean_fullname(message.name))
            writer.write("'%s': RequestClasses.%sRequestClass, \n" % (name, name))

    writer.untab()
    writer.write('\n}\n')

    writer.write('_json_converter = %s\n\n' % avro_json_converter)
    value = main_out.getvalue()
    main_out.close()
    return value, schema_names, request_names